319889: scheduled presentation displays scheduled subtasks

Previously the scheduled presentation would not display a subtasks in a
scheduled container unless it matched a query or the "Show non-matching"
subtasks option was selected.

Change-Id: I879d2fe242d36748f82eb322263bbed673c08b62
Task-Url: https://bugs.eclipse.org/bugs/show_bug.cgi?id=319889
Signed-off-by: Jaxsun McCarthy Huggan <jaxsun.mccarthy@tasktop.com>

3 files changed, 205 insertions, 36 deletions

diff --git a/org.eclipse.mylyn.tasks.ui.tests/src/org/eclipse/mylyn/internal/tasks/ui/views/PresentationFilterTest.java b/org.eclipse.mylyn.tasks.ui.tests/src/org/eclipse/mylyn/internal/tasks/ui/views/PresentationFilterTest.java
new file mode 100644
index 000000000..b73a9a394
--- /dev/null
+++ b/org.eclipse.mylyn.tasks.ui.tests/src/org/eclipse/mylyn/internal/tasks/ui/views/PresentationFilterTest.java
@@ -0,0 +1,170 @@
+/*******************************************************************************
+ * Copyright (c) 2016 Tasktop Technologies and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     Tasktop Technologies - initial API and implementation
+ *******************************************************************************/
+
+package org.eclipse.mylyn.internal.tasks.ui.views;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.Mockito.mock;
+
+import java.util.Calendar;
+
+import org.eclipse.jface.preference.IPreferenceStore;
+import org.eclipse.mylyn.internal.tasks.core.AbstractTask;
+import org.eclipse.mylyn.internal.tasks.core.AbstractTaskCategory;
+import org.eclipse.mylyn.internal.tasks.core.AbstractTaskContainer;
+import org.eclipse.mylyn.internal.tasks.core.DateRange;
+import org.eclipse.mylyn.internal.tasks.core.ITasksCoreConstants;
+import org.eclipse.mylyn.internal.tasks.core.LocalTask;
+import org.eclipse.mylyn.internal.tasks.core.RepositoryQuery;
+import org.eclipse.mylyn.internal.tasks.core.ScheduledTaskContainer;
+import org.eclipse.mylyn.internal.tasks.core.TaskActivityManager;
+import org.eclipse.mylyn.internal.tasks.core.TaskCategory;
+import org.eclipse.mylyn.internal.tasks.core.TaskTask;
+import org.eclipse.mylyn.internal.tasks.ui.ITasksUiPreferenceConstants;
+import org.eclipse.mylyn.internal.tasks.ui.TasksUiPlugin;
+import org.eclipse.mylyn.internal.tasks.ui.views.TaskScheduleContentProvider.StateTaskContainer;
+import org.eclipse.mylyn.tasks.core.IRepositoryQuery;
+import org.junit.AfterClass;
+import org.junit.Before;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+@SuppressWarnings("restriction")
+public class PresentationFilterTest {
+
+	private static boolean filterHidden;
+
+	private static boolean filterNonMatching;
+
+	private static IPreferenceStore preferenceStore;
+
+	private static PresentationFilter filter;
+
+	@BeforeClass
+	public static void recordSettings() {
+		preferenceStore = TasksUiPlugin.getDefault().getPreferenceStore();
+		filterHidden = preferenceStore.getBoolean(ITasksUiPreferenceConstants.FILTER_HIDDEN);
+		filterNonMatching = preferenceStore.getBoolean(ITasksUiPreferenceConstants.FILTER_NON_MATCHING);
+	}
+
+	@AfterClass
+	public static void resetSettings() {
+		preferenceStore.setValue(ITasksUiPreferenceConstants.FILTER_HIDDEN, filterHidden);
+		preferenceStore.setValue(ITasksUiPreferenceConstants.FILTER_NON_MATCHING, filterNonMatching);
+	}
+
+	@Before
+	public void setup() {
+		preferenceStore.setValue(ITasksUiPreferenceConstants.FILTER_HIDDEN, false);
+		preferenceStore.setValue(ITasksUiPreferenceConstants.FILTER_NON_MATCHING, false);
+		filter = new PresentationFilter();
+	}
+
+	@Test
+	public void readSettings() {
+		preferenceStore.setValue(ITasksUiPreferenceConstants.FILTER_HIDDEN, true);
+		preferenceStore.setValue(ITasksUiPreferenceConstants.FILTER_NON_MATCHING, false);
+		filter.updateSettings();
+		assertTrue(filter.isFilterHiddenQueries());
+		assertFalse(filter.isFilterNonMatching());
+		preferenceStore.setValue(ITasksUiPreferenceConstants.FILTER_HIDDEN, false);
+		preferenceStore.setValue(ITasksUiPreferenceConstants.FILTER_NON_MATCHING, true);
+		filter.updateSettings();
+		assertFalse(filter.isFilterHiddenQueries());
+		assertTrue(filter.isFilterNonMatching());
+	}
+
+	@Test
+	public void filterHiddenQueries() {
+		IRepositoryQuery visible = new RepositoryQuery("kind", "visible");
+		IRepositoryQuery hidden = new RepositoryQuery("kind", "hidden");
+		hidden.setAttribute(ITasksCoreConstants.ATTRIBUTE_HIDDEN, "true");
+		assertTrue(filter.select(null, visible));
+		assertTrue(filter.select(null, hidden));
+		filter.setFilterHiddenQueries(true);
+		assertTrue(filter.select(null, visible));
+		assertFalse(filter.select(null, hidden));
+	}
+
+	@Test
+	public void filterLocalTasks() {
+		AbstractTaskCategory category = new TaskCategory("category");
+		LocalTask task = new LocalTask("1", "task");
+		LocalTask subTask = new LocalTask("2", "subtask");
+		addChild(task, subTask);
+		addChild(category, task);
+
+		assertTrue(filter.select(category, task));
+		assertTrue(filter.select(task, subTask));
+
+		filter.setFilterNonMatching(true);
+
+		assertTrue(filter.select(category, task));
+		assertTrue(filter.select(task, subTask));
+	}
+
+	@Test
+	public void filterSubTasksInQuery() {
+		RepositoryQuery query = new RepositoryQuery("kind", "query");
+		assertMatchingSubTask(query, query, true, true);
+	}
+
+	@Test
+	public void filterSubTasksInCategory() {
+		TaskCategory category = new TaskCategory("category");
+		assertMatchingSubTask(category, category, true, true);
+	}
+
+	@Test
+	public void filterScheduledSubTasks() {
+		ScheduledTaskContainer schedule = new ScheduledTaskContainer(mock(TaskActivityManager.class),
+				new DateRange(Calendar.getInstance()));
+		RepositoryQuery query = new RepositoryQuery("kind", "query");
+		assertMatchingSubTask(query, schedule, true, false);
+	}
+
+	@Test
+	public void filterSubTasksInStateContainers() {
+		StateTaskContainer schedule = mock(StateTaskContainer.class);
+		RepositoryQuery query = new RepositoryQuery("kind", "query");
+		assertMatchingSubTask(query, schedule, false, false);
+	}
+
+	private void assertMatchingSubTask(AbstractTaskContainer taskContainer, AbstractTaskContainer subTaskContainer,
+			boolean subTasksVisibleInContainer, boolean subTaskVisibleInTask) {
+		TaskTask task = new TaskTask("kind", "http://eclipse.org", "task");
+		TaskTask subTask = new TaskTask("kind", "http://eclipse.org", "subTask");
+		TaskTask matchingSubTask = new TaskTask("kind", "http://eclipse.org", "matchingSubTask");
+		addChild(task, subTask);
+		addChild(task, matchingSubTask);
+		addChild(taskContainer, task);
+		addChild(subTaskContainer, matchingSubTask);
+
+		assertTrue(filter.select(taskContainer, task));
+		assertTrue(filter.select(task, subTask));
+		assertTrue(filter.select(task, matchingSubTask));
+		assertTrue(filter.select(subTaskContainer, matchingSubTask));
+
+		filter.setFilterNonMatching(true);
+
+		assertTrue(filter.select(taskContainer, task));
+		assertFalse(filter.select(task, subTask));
+		assertEquals(subTaskVisibleInTask, filter.select(task, matchingSubTask));
+		assertEquals(subTasksVisibleInContainer, filter.select(subTaskContainer, matchingSubTask));
+	}
+
+	private void addChild(AbstractTaskContainer container, AbstractTask task) {
+		container.internalAddChild(task);
+		task.getParentContainers().add(container);
+	}
+}
diff --git a/org.eclipse.mylyn.tasks.ui/src/org/eclipse/mylyn/internal/tasks/ui/TaskCompletionFilter.java b/org.eclipse.mylyn.tasks.ui/src/org/eclipse/mylyn/internal/tasks/ui/TaskCompletionFilter.java
index 2eeb24505..89c7519f5 100644
--- a/org.eclipse.mylyn.tasks.ui/src/org/eclipse/mylyn/internal/tasks/ui/TaskCompletionFilter.java
+++ b/org.eclipse.mylyn.tasks.ui/src/org/eclipse/mylyn/internal/tasks/ui/TaskCompletionFilter.java
@@ -30,7 +30,7 @@ public class TaskCompletionFilter extends AbstractTaskListFilter {
 			if (task.isCompleted()) {
 				Collection<ITask> children = task.getChildren();
 				for (ITask child : children) {
-					if (PresentationFilter.getInstance().select(element) && select(element, child)) {
+					if (PresentationFilter.getInstance().select(element, child) && select(element, child)) {
 						return true;
 					}
 				}
diff --git a/org.eclipse.mylyn.tasks.ui/src/org/eclipse/mylyn/internal/tasks/ui/views/PresentationFilter.java b/org.eclipse.mylyn.tasks.ui/src/org/eclipse/mylyn/internal/tasks/ui/views/PresentationFilter.java
index a3c47cfc3..aba6dcd31 100644
--- a/org.eclipse.mylyn.tasks.ui/src/org/eclipse/mylyn/internal/tasks/ui/views/PresentationFilter.java
+++ b/org.eclipse.mylyn.tasks.ui/src/org/eclipse/mylyn/internal/tasks/ui/views/PresentationFilter.java
@@ -15,11 +15,11 @@ import org.eclipse.mylyn.internal.tasks.core.AbstractTask;
 import org.eclipse.mylyn.internal.tasks.core.AbstractTaskCategory;
 import org.eclipse.mylyn.internal.tasks.core.AbstractTaskContainer;
 import org.eclipse.mylyn.internal.tasks.core.ITasksCoreConstants;
+import org.eclipse.mylyn.internal.tasks.core.ScheduledTaskContainer;
 import org.eclipse.mylyn.internal.tasks.core.TaskTask;
 import org.eclipse.mylyn.internal.tasks.ui.AbstractTaskListFilter;
 import org.eclipse.mylyn.internal.tasks.ui.ITasksUiPreferenceConstants;
 import org.eclipse.mylyn.internal.tasks.ui.TasksUiPlugin;
-import org.eclipse.mylyn.tasks.core.IAttributeContainer;
 import org.eclipse.mylyn.tasks.core.IRepositoryQuery;
 import org.eclipse.mylyn.tasks.core.ITask;
 
@@ -38,7 +38,10 @@ public class PresentationFilter extends AbstractTaskListFilter {
 
 	private boolean filterNonMatching;
 
-	private PresentationFilter() {
+	/**
+	 * @noreference This method is not intended to be referenced by clients.
+	 */
+	PresentationFilter() {
 		updateSettings();
 	}
 
@@ -50,37 +53,39 @@ public class PresentationFilter extends AbstractTaskListFilter {
 		return filterNonMatching;
 	}
 
-	public boolean select(Object element) {
-		// filter hidden queries
+	@Override
+	public boolean select(Object parent, Object element) {
 		if (element instanceof IRepositoryQuery) {
-			if (!filterHiddenQueries) {
-				return true;
-			}
-			return isQueryVisible(element);
+			return selectQuery((IRepositoryQuery) element);
 		}
-		// filter repository sub-tasks not connected to queries or categories
+		// only filter repository tasks
 		if (element instanceof TaskTask) {
-			if (!filterNonMatching) {
-				return true;
-			}
-			for (AbstractTaskContainer container : ((AbstractTask) element).getParentContainers()) {
-				// categories and local subtasks are always visible
-				if (container instanceof AbstractTaskCategory) {
-					return true;
-				}
-				// show task if is contained in a query
-				if (container instanceof IRepositoryQuery && (!filterHiddenQueries || isQueryVisible(container))) {
-					return true;
-				}
-			}
-			return false;
+			return selectTask(parent, (TaskTask) element);
 		}
 		return true;
 	}
 
-	@Override
-	public boolean select(Object parent, Object element) {
-		return select(element);
+	private boolean selectQuery(IRepositoryQuery query) {
+		if (!filterHiddenQueries) {
+			return true;
+		}
+		return !Boolean.parseBoolean(query.getAttribute(ITasksCoreConstants.ATTRIBUTE_HIDDEN));
+	}
+
+	private boolean selectTask(Object parent, TaskTask task) {
+		if (!filterNonMatching) {
+			return true;
+		}
+		// tasks matching a query or category should be included
+		if (isInVisibleQuery(task)) {
+			return true;
+		}
+		// explicitly scheduled subtasks should be shown in those containers
+		if (parent != null && parent.getClass().equals(ScheduledTaskContainer.class)) {
+			return true;
+		}
+
+		return false;
 	}
 
 	public void setFilterHiddenQueries(boolean enabled) {
@@ -92,18 +97,13 @@ public class PresentationFilter extends AbstractTaskListFilter {
 	}
 
 	public void updateSettings() {
-		setFilterHiddenQueries(TasksUiPlugin.getDefault()
-				.getPreferenceStore()
-				.getBoolean(ITasksUiPreferenceConstants.FILTER_HIDDEN));
+		setFilterHiddenQueries(
+				TasksUiPlugin.getDefault().getPreferenceStore().getBoolean(ITasksUiPreferenceConstants.FILTER_HIDDEN));
 		setFilterNonMatching(TasksUiPlugin.getDefault()
 				.getPreferenceStore()
 				.getBoolean(ITasksUiPreferenceConstants.FILTER_NON_MATCHING));
 	}
 
-	private boolean isQueryVisible(Object element) {
-		return !Boolean.parseBoolean(((IAttributeContainer) element).getAttribute(ITasksCoreConstants.ATTRIBUTE_HIDDEN));
-	}
-
 	public boolean isInVisibleQuery(ITask task) {
 		for (AbstractTaskContainer container : ((AbstractTask) task).getParentContainers()) {
 			// categories and local subtasks are always visible
@@ -111,11 +111,10 @@ public class PresentationFilter extends AbstractTaskListFilter {
 				return true;
 			}
 			// show task if is contained in a query
-			if (container instanceof IRepositoryQuery && (!filterHiddenQueries || isQueryVisible(container))) {
+			if (container instanceof IRepositoryQuery && selectQuery((IRepositoryQuery) container)) {
 				return true;
 			}
 		}
 		return false;
 	}
-
 }