Merge branch 'stable-3.7'

* stable-3.7:
  Prepare post 3.7.0.201502031740-rc1 builds
  EGit v3.7.0.201502031740-rc1
  Lookup active window before opening commit selection dialog
  [stagingview] "Updating index" should indicate that view is "busy"
  [stagingview] "Refresh" operation should indicate that view is "busy"
  Update readme to describe current state of symlink support
  Let staging view use submodule repos
  UI Activator: allow tracing if workbench UI is active
  Jobs should not unnecessarily lock the workspace
  Open mergetool by default in staging view when in conflicting state
  Don't run "Compare with previous" in UI thread
  Implement hasChildren() to avoid diff calculation in UI thread
  Don't run indexDiff.diff() in UI thread
  Always run compare input calculation in background thread
  Scalability: don't run incremental update if there are too many
changes

Change-Id: I5452a465bb4b2bbd988f5f11fd4bf395ee875272
Signed-off-by: Matthias Sohn <matthias.sohn@sap.com>

2 files changed, 346 insertions, 0 deletions

diff --git a/org.eclipse.egit.core.test/src/org/eclipse/egit/core/internal/indexdiff/IndexDiffCacheEntryTest.java b/org.eclipse.egit.core.test/src/org/eclipse/egit/core/internal/indexdiff/IndexDiffCacheEntryTest.java
new file mode 100644
index 0000000000..650abf5d0e
--- /dev/null
+++ b/org.eclipse.egit.core.test/src/org/eclipse/egit/core/internal/indexdiff/IndexDiffCacheEntryTest.java
@@ -0,0 +1,258 @@
+/*******************************************************************************
+ * Copyright (C) 2015 Andrey Loskutov <loskutov@gmx.de> 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
+ *******************************************************************************/
+package org.eclipse.egit.core.internal.indexdiff;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+
+import org.eclipse.core.resources.IResource;
+import org.eclipse.core.resources.IWorkspaceRunnable;
+import org.eclipse.core.resources.ResourcesPlugin;
+import org.eclipse.core.runtime.CoreException;
+import org.eclipse.core.runtime.IProgressMonitor;
+import org.eclipse.core.runtime.jobs.IJobManager;
+import org.eclipse.core.runtime.jobs.Job;
+import org.eclipse.egit.core.Activator;
+import org.eclipse.egit.core.JobFamilies;
+import org.eclipse.egit.core.test.GitTestCase;
+import org.eclipse.egit.core.test.TestRepository;
+import org.eclipse.jgit.lib.Repository;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+public class IndexDiffCacheEntryTest extends GitTestCase {
+
+	// trigger reload if more than one file is changed
+	private static final int MAX_FILES_FOR_UPDATE = 1;
+
+	private static final int MAX_WAIT_TIME = 10 * 1000;
+
+
+	private TestRepository testRepository;
+
+	private Repository repository;
+
+	private IndexDiffCacheEntry2 entry;
+
+	@Test
+	public void basicTest() throws Exception {
+		prepareCacheEntry();
+
+		entry.refresh();
+		waitForJobs(MAX_WAIT_TIME, JobFamilies.INDEX_DIFF_CACHE_UPDATE);
+
+		// on refresh, full reload is triggered
+		assertTrue(entry.reloadScheduled);
+		assertFalse(entry.updateScheduled);
+		cleanEntryFlags();
+
+		entry.refreshFiles(Arrays.asList("a"));
+		waitForJobs(MAX_WAIT_TIME, JobFamilies.INDEX_DIFF_CACHE_UPDATE);
+
+		// one single file: no reload
+		assertFalse(entry.reloadScheduled);
+		assertTrue(entry.updateScheduled);
+		cleanEntryFlags();
+
+		entry.refreshFiles(Arrays.asList("a", "b"));
+		waitForJobs(MAX_WAIT_TIME, JobFamilies.INDEX_DIFF_CACHE_UPDATE);
+
+		// two files: update is triggered, but decides to run full reload
+		assertTrue(entry.reloadScheduled);
+		assertTrue(entry.updateScheduled);
+		cleanEntryFlags();
+
+		entry.getUpdateJob().addChanges(Arrays.asList("a", "b"),
+				Collections.<IResource> emptyList());
+		waitForJobs(MAX_WAIT_TIME, JobFamilies.INDEX_DIFF_CACHE_UPDATE);
+
+		// two files: update is not triggered (we call through the job directly)
+		// but this calls full reload
+		assertTrue(entry.reloadScheduled);
+		assertFalse(entry.updateScheduled);
+		cleanEntryFlags();
+	}
+
+	@Test
+	public void testReloadAndUpdate() throws Exception {
+		prepareCacheEntry();
+
+		testRepository.connect(project.project);
+		waitForJobs(MAX_WAIT_TIME, JobFamilies.INDEX_DIFF_CACHE_UPDATE);
+
+		// on a simple connect, nothing should be called
+		assertFalse(entry.reloadScheduled);
+		assertFalse(entry.updateScheduled);
+		cleanEntryFlags();
+
+		// adds .project and .classpath files: more than limit of 1,
+		// so update redirects to reload
+		testRepository.addToIndex(project.project);
+		waitForJobs(MAX_WAIT_TIME, JobFamilies.INDEX_DIFF_CACHE_UPDATE);
+
+		assertTrue(entry.reloadScheduled);
+		assertTrue(entry.updateScheduled);
+		cleanEntryFlags();
+
+		testRepository.createInitialCommit("first commit\n");
+		waitForJobs(MAX_WAIT_TIME, JobFamilies.INDEX_DIFF_CACHE_UPDATE);
+
+		// RefsChangedEvent causes always full update
+		assertTrue(entry.reloadScheduled);
+		// single "dummy" file from commit
+		assertTrue(entry.updateScheduled);
+		cleanEntryFlags();
+
+		ResourcesPlugin.getWorkspace().run(new IWorkspaceRunnable() {
+			public void run(IProgressMonitor monitor) throws CoreException {
+				try {
+					project.createFile("bla", "bla\n".getBytes("UTF-8"));
+					project.createFile("blup", "blup\n".getBytes("UTF-8"));
+				} catch (Exception e) {
+					throw new CoreException(Activator.error("Failure", e));
+				}
+
+			}
+		}, null);
+		waitForJobs(MAX_WAIT_TIME, JobFamilies.INDEX_DIFF_CACHE_UPDATE);
+
+		// adds 2 files: more than limit of 1,
+		// so update redirects to reload
+		assertTrue(entry.reloadScheduled);
+		assertTrue(entry.updateScheduled);
+		cleanEntryFlags();
+
+		ResourcesPlugin.getWorkspace().run(new IWorkspaceRunnable() {
+			public void run(IProgressMonitor monitor) throws CoreException {
+				try {
+					project.createFile("blip", "blip\n".getBytes("UTF-8"));
+				} catch (Exception e) {
+					throw new CoreException(Activator.error("Failure", e));
+				}
+
+			}
+		}, null);
+		waitForJobs(MAX_WAIT_TIME, JobFamilies.INDEX_DIFF_CACHE_UPDATE);
+
+		// adds 1 file: less than limit of 1, so no reload
+		assertFalse(entry.reloadScheduled);
+		assertTrue(entry.updateScheduled);
+		cleanEntryFlags();
+
+		ResourcesPlugin.getWorkspace().run(new IWorkspaceRunnable() {
+			public void run(IProgressMonitor monitor) throws CoreException {
+				try {
+					project.createFile(".gitignore", "\n".getBytes("UTF-8"));
+				} catch (Exception e) {
+					throw new CoreException(Activator.error("Failure", e));
+				}
+
+			}
+		}, null);
+		waitForJobs(MAX_WAIT_TIME, JobFamilies.INDEX_DIFF_CACHE_UPDATE);
+
+		// adds .gitignore file: always full reload
+		assertTrue(entry.reloadScheduled);
+		assertFalse(entry.updateScheduled);
+		cleanEntryFlags();
+	}
+
+	/**
+	 * Waits at least 50 milliseconds until no jobs of given family are running
+	 *
+	 * @param maxWaitTime
+	 * @param family
+	 * @throws InterruptedException
+	 */
+	private void waitForJobs(long maxWaitTime, Object family)
+			throws InterruptedException {
+		Thread.sleep(50);
+		long start = System.currentTimeMillis();
+		IJobManager jobManager = Job.getJobManager();
+
+		Job[] jobs = jobManager.find(family);
+		while (jobs.length > 0) {
+			Thread.sleep(100);
+			jobs = jobManager.find(family);
+			if (System.currentTimeMillis() - start > maxWaitTime) {
+				return;
+			}
+		}
+	}
+
+	private void cleanEntryFlags() {
+		entry.reloadScheduled = false;
+		entry.updateScheduled = false;
+	}
+
+	private IndexDiffCacheEntry2 prepareCacheEntry() throws Exception {
+		entry = new IndexDiffCacheEntry2(repository);
+		waitForJobs(MAX_WAIT_TIME, JobFamilies.INDEX_DIFF_CACHE_UPDATE);
+
+		// on creation, full reload is triggered
+		assertTrue(entry.reloadScheduled);
+		assertFalse(entry.updateScheduled);
+		cleanEntryFlags();
+		return entry;
+	}
+
+	@Before
+	public void setUp() throws Exception {
+		super.setUp();
+		testRepository = new TestRepository(gitDir);
+		repository = testRepository.getRepository();
+	}
+
+	@After
+	public void tearDown() throws Exception {
+		entry.dispose();
+		testRepository.dispose();
+		repository = null;
+		super.tearDown();
+	}
+
+	class IndexDiffCacheEntry2 extends IndexDiffCacheEntry {
+
+		boolean reloadScheduled;
+
+		boolean updateScheduled;
+
+		public IndexDiffCacheEntry2(Repository repository) {
+			super(repository);
+		}
+
+		@Override
+		protected void scheduleReloadJob(String trigger) {
+			reloadScheduled = true;
+			super.scheduleReloadJob(trigger);
+		}
+
+		@Override
+		protected void scheduleUpdateJob(Collection<String> filesToUpdate,
+				Collection<IResource> resourcesToUpdate) {
+			updateScheduled = true;
+			super.scheduleUpdateJob(filesToUpdate, resourcesToUpdate);
+		}
+
+		@Override
+		protected boolean shouldReload(Collection<String> filesToUpdate) {
+			return filesToUpdate.size() > MAX_FILES_FOR_UPDATE;
+		}
+
+		public IndexDiffUpdateJob getUpdateJob() {
+			return super.getUpdateJob();
+		}
+	}
+
+}
diff --git a/org.eclipse.egit.core.test/src/org/eclipse/egit/core/internal/indexdiff/IndexDiffDataTest.java b/org.eclipse.egit.core.test/src/org/eclipse/egit/core/internal/indexdiff/IndexDiffDataTest.java
new file mode 100644
index 0000000000..3e3886804a
--- /dev/null
+++ b/org.eclipse.egit.core.test/src/org/eclipse/egit/core/internal/indexdiff/IndexDiffDataTest.java
@@ -0,0 +1,88 @@
+/*******************************************************************************
+ * Copyright (C) 2015 Andrey Loskutov <loskutov@gmx.de> 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
+ *******************************************************************************/
+package org.eclipse.egit.core.internal.indexdiff;
+
+import static java.util.Arrays.asList;
+import static org.eclipse.egit.core.internal.indexdiff.IndexDiffData.isAnyPrefixOf;
+import static org.eclipse.egit.core.internal.indexdiff.IndexDiffData.mergeIgnored;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.Set;
+
+import org.eclipse.egit.core.test.GitTestCase;
+import org.junit.Test;
+
+public class IndexDiffDataTest extends GitTestCase {
+
+	@Test
+	public void testIsAnyPrefixOf() {
+		Collection<String> possiblePrefixes = asList("", "/");
+		assertTrue(isAnyPrefixOf("", possiblePrefixes));
+
+		possiblePrefixes = asList("", "/");
+		assertTrue(isAnyPrefixOf("/", possiblePrefixes));
+
+		possiblePrefixes = asList("a");
+		assertTrue(isAnyPrefixOf("a", possiblePrefixes));
+
+		possiblePrefixes = asList("a/");
+		assertTrue(isAnyPrefixOf("a", possiblePrefixes));
+
+		possiblePrefixes = asList("b");
+		assertFalse(isAnyPrefixOf("a", possiblePrefixes));
+
+		possiblePrefixes = asList("b", "ab", "b/", "aa");
+		assertFalse(isAnyPrefixOf("a", possiblePrefixes));
+	}
+
+	@Test
+	public void testMergeIgnored() {
+		Set<String> result;
+		Set<String> expected = new HashSet<String>();
+		Set<String> oldIgnoredPaths = new HashSet<String>();
+		Collection<String> changedPaths = new HashSet<String>();
+		Set<String> newIgnoredPaths = new HashSet<String>();
+
+		result = mergeIgnored(oldIgnoredPaths, changedPaths, newIgnoredPaths);
+		assertEquals(expected, result);
+
+		newIgnoredPaths.add("a");
+		changedPaths.add("a");
+		expected.add("a");
+		result = mergeIgnored(oldIgnoredPaths, changedPaths, newIgnoredPaths);
+		assertEquals(expected, result);
+
+		newIgnoredPaths.add("b");
+		expected.add("b");
+		result = mergeIgnored(oldIgnoredPaths, changedPaths, newIgnoredPaths);
+		assertEquals(expected, result);
+
+		changedPaths.add("b");
+		result = mergeIgnored(oldIgnoredPaths, changedPaths, newIgnoredPaths);
+		assertEquals(expected, result);
+
+		oldIgnoredPaths.add("b");
+		result = mergeIgnored(oldIgnoredPaths, changedPaths, newIgnoredPaths);
+		assertEquals(expected, result);
+
+		oldIgnoredPaths.add("c");
+		expected.add("c");
+		result = mergeIgnored(oldIgnoredPaths, changedPaths, newIgnoredPaths);
+		assertEquals(expected, result);
+
+		newIgnoredPaths.add("b");
+		expected.add("b");
+		result = mergeIgnored(oldIgnoredPaths, changedPaths, newIgnoredPaths);
+		assertEquals(expected, result);
+	}
+}