aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
authorDariusz Luksza2011-08-17 06:43:35 (EDT)
committerMatthias Sohn2011-08-17 06:43:35 (EDT)
commit679cab9b3297e550a9ae04b88ba839dc9eb84957 (patch)
tree15ef803c3e8591f1fbbff74f84988e3746b788fe
parent100e9429b5a7eea8383c6e693d17b6233794c488 (diff)
downloadjgit-679cab9b3297e550a9ae04b88ba839dc9eb84957.zip
jgit-679cab9b3297e550a9ae04b88ba839dc9eb84957.tar.gz
jgit-679cab9b3297e550a9ae04b88ba839dc9eb84957.tar.bz2
Adds DiffEntry.scan(TreeWalk, boolean) methodrefs/changes/19/3819/10
Adds method into DiffEntry class that allows to specify whether changed trees are included in scanning result list. By default changed trees aren't added, but in some cases having changed tree would be useful. Also adds check for tree count in TreeWalk and when it is different from two it will thrown an IllegalArgumentException. This change is required by egit I7ddb21e7ff54333dd6d7ace3209bbcf83da2b219 Change-Id: I5a680a73e1cffa18ade3402cc86008f46c1da1f1 Signed-off-by: Dariusz Luksza <dariusz@luksza.org> Signed-off-by: Matthias Sohn <matthias.sohn@sap.com>
-rw-r--r--org.eclipse.jgit.test/META-INF/MANIFEST.MF3
-rw-r--r--org.eclipse.jgit.test/tst/org/eclipse/jgit/diff/DiffEntryTest.java298
-rw-r--r--org.eclipse.jgit/resources/org/eclipse/jgit/JGitText.properties2
-rw-r--r--org.eclipse.jgit/src/org/eclipse/jgit/JGitText.java2
-rw-r--r--org.eclipse.jgit/src/org/eclipse/jgit/diff/DiffEntry.java38
5 files changed, 341 insertions, 2 deletions
diff --git a/org.eclipse.jgit.test/META-INF/MANIFEST.MF b/org.eclipse.jgit.test/META-INF/MANIFEST.MF
index 85f6c30..d7f7ef1 100644
--- a/org.eclipse.jgit.test/META-INF/MANIFEST.MF
+++ b/org.eclipse.jgit.test/META-INF/MANIFEST.MF
@@ -39,7 +39,8 @@ Import-Package: org.eclipse.jgit;version="[1.1.0,1.2.0)",
org.eclipse.jgit.util;version="[1.1.0,1.2.0)",
org.eclipse.jgit.util.io;version="[1.1.0,1.2.0)",
org.junit;version="[4.0.0,5.0.0)",
- org.hamcrest.core;version="[1.1.0,2.0.0)"
+ org.hamcrest.core;version="[1.1.0,2.0.0)",
+ org.hamcrest;version="[1.1.0,2.0.0)"
Require-Bundle: com.jcraft.jsch;bundle-version="[0.1.37,0.2.0)"
Export-Package: org.eclipse.jgit.lib
diff --git a/org.eclipse.jgit.test/tst/org/eclipse/jgit/diff/DiffEntryTest.java b/org.eclipse.jgit.test/tst/org/eclipse/jgit/diff/DiffEntryTest.java
new file mode 100644
index 0000000..21069ef
--- /dev/null
+++ b/org.eclipse.jgit.test/tst/org/eclipse/jgit/diff/DiffEntryTest.java
@@ -0,0 +1,298 @@
+/*
+ * Copyright (C) 2011, Dariusz Luksza <dariusz@luksza.org>
+ * and other copyright owners as documented in the project's IP log.
+ *
+ * This program and the accompanying materials are made available
+ * under the terms of the Eclipse Distribution License v1.0 which
+ * accompanies this distribution, is reproduced below, and is
+ * available at http://www.eclipse.org/org/documents/edl-v10.php
+ *
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or
+ * without modification, are permitted provided that the following
+ * conditions are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided
+ * with the distribution.
+ *
+ * - Neither the name of the Eclipse Foundation, Inc. nor the
+ * names of its contributors may be used to endorse or promote
+ * products derived from this software without specific prior
+ * written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+package org.eclipse.jgit.diff;
+
+import static org.eclipse.jgit.diff.DiffEntry.DEV_NULL;
+import static org.eclipse.jgit.util.FileUtils.delete;
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.CoreMatchers.notNullValue;
+import static org.junit.Assert.assertThat;
+
+import java.io.File;
+import java.util.List;
+
+import org.eclipse.jgit.api.Git;
+import org.eclipse.jgit.diff.DiffEntry.ChangeType;
+import org.eclipse.jgit.lib.RepositoryTestCase;
+import org.eclipse.jgit.revwalk.RevCommit;
+import org.eclipse.jgit.treewalk.EmptyTreeIterator;
+import org.eclipse.jgit.treewalk.FileTreeIterator;
+import org.eclipse.jgit.treewalk.TreeWalk;
+import org.eclipse.jgit.util.FileUtils;
+import org.junit.Test;
+
+public class DiffEntryTest extends RepositoryTestCase {
+
+ @Test
+ public void shouldListAddedFileInInitialCommit() throws Exception {
+ // given
+ writeTrashFile("a.txt", "content");
+ Git git = new Git(db);
+ git.add().addFilepattern("a.txt").call();
+ RevCommit c = git.commit().setMessage("initial commit").call();
+
+ // when
+ TreeWalk walk = new TreeWalk(db);
+ walk.addTree(new EmptyTreeIterator());
+ walk.addTree(c.getTree());
+ List<DiffEntry> result = DiffEntry.scan(walk);
+
+ // then
+ assertThat(result, notNullValue());
+ assertThat(Integer.valueOf(result.size()), is(Integer.valueOf(1)));
+
+ DiffEntry entry = result.get(0);
+ assertThat(entry.getChangeType(), is(ChangeType.ADD));
+ assertThat(entry.getNewPath(), is("a.txt"));
+ assertThat(entry.getOldPath(), is(DEV_NULL));
+ }
+
+ @Test
+ public void shouldListAddedFileBetweenTwoCommits() throws Exception {
+ // given
+ Git git = new Git(db);
+ RevCommit c1 = git.commit().setMessage("initial commit").call();
+ writeTrashFile("a.txt", "content");
+ git.add().addFilepattern("a.txt").call();
+ RevCommit c2 = git.commit().setMessage("second commit").call();
+
+ // when
+ TreeWalk walk = new TreeWalk(db);
+ walk.addTree(c1.getTree());
+ walk.addTree(c2.getTree());
+ List<DiffEntry> result = DiffEntry.scan(walk);
+
+ // then
+ assertThat(result, notNullValue());
+ assertThat(Integer.valueOf(result.size()), is(Integer.valueOf(1)));
+
+ DiffEntry entry = result.get(0);
+ assertThat(entry.getChangeType(), is(ChangeType.ADD));
+ assertThat(entry.getNewPath(), is("a.txt"));
+ assertThat(entry.getOldPath(), is(DEV_NULL));
+ }
+
+ @Test
+ public void shouldListModificationBetweenTwoCommits() throws Exception {
+ // given
+ Git git = new Git(db);
+ File file = writeTrashFile("a.txt", "content");
+ git.add().addFilepattern("a.txt").call();
+ RevCommit c1 = git.commit().setMessage("initial commit").call();
+ write(file, "new content");
+ RevCommit c2 = git.commit().setAll(true).setMessage("second commit")
+ .call();
+
+ // when
+ TreeWalk walk = new TreeWalk(db);
+ walk.addTree(c1.getTree());
+ walk.addTree(c2.getTree());
+ List<DiffEntry> result = DiffEntry.scan(walk);
+
+ // then
+ assertThat(result, notNullValue());
+ assertThat(Integer.valueOf(result.size()), is(Integer.valueOf(1)));
+
+ DiffEntry entry = result.get(0);
+ assertThat(entry.getChangeType(), is(ChangeType.MODIFY));
+ assertThat(entry.getNewPath(), is("a.txt"));
+ }
+
+ @Test
+ public void shouldListDeletionBetweenTwoCommits() throws Exception {
+ // given
+ Git git = new Git(db);
+ File file = writeTrashFile("a.txt", "content");
+ git.add().addFilepattern("a.txt").call();
+ RevCommit c1 = git.commit().setMessage("initial commit").call();
+ delete(file);
+ RevCommit c2 = git.commit().setAll(true).setMessage("delete a.txt")
+ .call();
+
+ // when
+ TreeWalk walk = new TreeWalk(db);
+ walk.addTree(c1.getTree());
+ walk.addTree(c2.getTree());
+ List<DiffEntry> result = DiffEntry.scan(walk);
+
+ // then
+ assertThat(result, notNullValue());
+ assertThat(Integer.valueOf(result.size()), is(Integer.valueOf(1)));
+
+ DiffEntry entry = result.get(0);
+ assertThat(entry.getOldPath(), is("a.txt"));
+ assertThat(entry.getNewPath(), is(DEV_NULL));
+ assertThat(entry.getChangeType(), is(ChangeType.DELETE));
+ }
+
+ @Test
+ public void shouldListModificationInDirWithoutModifiedTrees()
+ throws Exception {
+ // given
+ Git git = new Git(db);
+ File tree = new File(new File(db.getWorkTree(), "a"), "b");
+ FileUtils.mkdirs(tree);
+ File file = new File(tree, "c.txt");
+ FileUtils.createNewFile(file);
+ write(file, "content");
+ git.add().addFilepattern("a").call();
+ RevCommit c1 = git.commit().setMessage("initial commit").call();
+ write(file, "new line");
+ RevCommit c2 = git.commit().setAll(true).setMessage("second commit")
+ .call();
+
+ // when
+ TreeWalk walk = new TreeWalk(db);
+ walk.addTree(c1.getTree());
+ walk.addTree(c2.getTree());
+ walk.setRecursive(true);
+ List<DiffEntry> result = DiffEntry.scan(walk);
+
+ // then
+ assertThat(result, notNullValue());
+ assertThat(Integer.valueOf(result.size()), is(Integer.valueOf(1)));
+
+ DiffEntry entry = result.get(0);
+ assertThat(entry.getChangeType(), is(ChangeType.MODIFY));
+ assertThat(entry.getNewPath(), is("a/b/c.txt"));
+ }
+
+ @Test
+ public void shouldListModificationInDirWithModifiedTrees() throws Exception {
+ // given
+ Git git = new Git(db);
+ File tree = new File(new File(db.getWorkTree(), "a"), "b");
+ FileUtils.mkdirs(tree);
+ File file = new File(tree, "c.txt");
+ FileUtils.createNewFile(file);
+ write(file, "content");
+ git.add().addFilepattern("a").call();
+ RevCommit c1 = git.commit().setMessage("initial commit").call();
+ write(file, "new line");
+ RevCommit c2 = git.commit().setAll(true).setMessage("second commit")
+ .call();
+
+ // when
+ TreeWalk walk = new TreeWalk(db);
+ walk.addTree(c1.getTree());
+ walk.addTree(c2.getTree());
+ List<DiffEntry> result = DiffEntry.scan(walk, true);
+
+ // then
+ assertThat(result, notNullValue());
+ assertThat(Integer.valueOf(result.size()), is(Integer.valueOf(3)));
+
+ DiffEntry entry = result.get(0);
+ assertThat(entry.getChangeType(), is(ChangeType.MODIFY));
+ assertThat(entry.getNewPath(), is("a"));
+
+ entry = result.get(1);
+ assertThat(entry.getChangeType(), is(ChangeType.MODIFY));
+ assertThat(entry.getNewPath(), is("a/b"));
+
+ entry = result.get(2);
+ assertThat(entry.getChangeType(), is(ChangeType.MODIFY));
+ assertThat(entry.getNewPath(), is("a/b/c.txt"));
+ }
+
+ @Test
+ public void shouldListChangesInWorkingTree() throws Exception {
+ // given
+ writeTrashFile("a.txt", "content");
+ Git git = new Git(db);
+ git.add().addFilepattern("a.txt").call();
+ RevCommit c = git.commit().setMessage("initial commit").call();
+ writeTrashFile("b.txt", "new line");
+
+ // when
+ TreeWalk walk = new TreeWalk(db);
+ walk.addTree(c.getTree());
+ walk.addTree(new FileTreeIterator(db));
+ List<DiffEntry> result = DiffEntry.scan(walk, true);
+
+ // then
+ assertThat(Integer.valueOf(result.size()), is(Integer.valueOf(1)));
+ DiffEntry entry = result.get(0);
+
+ assertThat(entry.getChangeType(), is(ChangeType.ADD));
+ assertThat(entry.getNewPath(), is("b.txt"));
+ }
+
+ @Test(expected = IllegalArgumentException.class)
+ public void shouldThrowIAEWhenTreeWalkHasLessThanTwoTrees()
+ throws Exception {
+ // given - we don't need anything here
+
+ // when
+ TreeWalk walk = new TreeWalk(db);
+ walk.addTree(new EmptyTreeIterator());
+ DiffEntry.scan(walk);
+ }
+
+ @Test(expected = IllegalArgumentException.class)
+ public void shouldThrowIAEWhenTreeWalkHasMoreThanTwoTrees()
+ throws Exception {
+ // given - we don't need anything here
+
+ // when
+ TreeWalk walk = new TreeWalk(db);
+ walk.addTree(new EmptyTreeIterator());
+ walk.addTree(new EmptyTreeIterator());
+ walk.addTree(new EmptyTreeIterator());
+ DiffEntry.scan(walk);
+ }
+
+ @Test(expected = IllegalArgumentException.class)
+ public void shouldThrowIAEWhenScanShouldIncludeTreesAndWalkIsRecursive()
+ throws Exception {
+ // given - we don't need anything here
+
+ // when
+ TreeWalk walk = new TreeWalk(db);
+ walk.addTree(new EmptyTreeIterator());
+ walk.addTree(new EmptyTreeIterator());
+ walk.setRecursive(true);
+ DiffEntry.scan(walk, true);
+ }
+
+}
diff --git a/org.eclipse.jgit/resources/org/eclipse/jgit/JGitText.properties b/org.eclipse.jgit/resources/org/eclipse/jgit/JGitText.properties
index 8c87d2a..9cc0e02 100644
--- a/org.eclipse.jgit/resources/org/eclipse/jgit/JGitText.properties
+++ b/org.eclipse.jgit/resources/org/eclipse/jgit/JGitText.properties
@@ -492,3 +492,5 @@ year=year
years=years
yearsAgo={0} years ago
yearsMonthsAgo={0} {1}, {2} {3} ago
+treeWalkMustHaveExactlyTwoTrees=TreeWalk should have exactly two trees.
+cannotBeRecursiveWhenTreesAreIncluded=TreeWalk shouldn't be recursive when tree objects are included.
diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/JGitText.java b/org.eclipse.jgit/src/org/eclipse/jgit/JGitText.java
index af20477..3b645e8 100644
--- a/org.eclipse.jgit/src/org/eclipse/jgit/JGitText.java
+++ b/org.eclipse.jgit/src/org/eclipse/jgit/JGitText.java
@@ -552,4 +552,6 @@ public class JGitText extends TranslationBundle {
/***/ public String years;
/***/ public String yearsAgo;
/***/ public String yearsMonthsAgo;
+ /***/ public String treeWalkMustHaveExactlyTwoTrees;
+ /***/ public String cannotBeRecursiveWhenTreesAreIncluded;
}
diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/diff/DiffEntry.java b/org.eclipse.jgit/src/org/eclipse/jgit/diff/DiffEntry.java
index 76d86a9..5bccccf 100644
--- a/org.eclipse.jgit/src/org/eclipse/jgit/diff/DiffEntry.java
+++ b/org.eclipse.jgit/src/org/eclipse/jgit/diff/DiffEntry.java
@@ -48,6 +48,7 @@ import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
+import org.eclipse.jgit.JGitText;
import org.eclipse.jgit.lib.AbbreviatedObjectId;
import org.eclipse.jgit.lib.AnyObjectId;
import org.eclipse.jgit.lib.FileMode;
@@ -106,8 +107,40 @@ public class DiffEntry {
* @return headers describing the changed files.
* @throws IOException
* the repository cannot be accessed.
+ * @throws IllegalArgumentException
+ * When given TreeWalk doesn't have exactly two trees.
*/
public static List<DiffEntry> scan(TreeWalk walk) throws IOException {
+ return scan(walk, false);
+ }
+
+ /**
+ * Convert the TreeWalk into DiffEntry headers, depending on
+ * {@code includeTrees} it will add tree objects into result or not.
+ *
+ * @param walk
+ * the TreeWalk to walk through. Must have exactly two trees and
+ * when {@code includeTrees} parameter is {@code true} it can't
+ * be recursive.
+ * @param includeTrees
+ * include tree object's.
+ * @return headers describing the changed files.
+ * @throws IOException
+ * the repository cannot be accessed.
+ * @throws IllegalArgumentException
+ * when {@code includeTrees} is true and given TreeWalk is
+ * recursive. Or when given TreeWalk doesn't have exactly two
+ * trees
+ */
+ public static List<DiffEntry> scan(TreeWalk walk, boolean includeTrees)
+ throws IOException {
+ if (walk.getTreeCount() != 2)
+ throw new IllegalArgumentException(
+ JGitText.get().treeWalkMustHaveExactlyTwoTrees);
+ if (includeTrees && walk.isRecursive())
+ throw new IllegalArgumentException(
+ JGitText.get().cannotBeRecursiveWhenTreesAreIncluded);
+
List<DiffEntry> r = new ArrayList<DiffEntry>();
MutableObjectId idBuf = new MutableObjectId();
while (walk.next()) {
@@ -133,13 +166,16 @@ public class DiffEntry {
entry.changeType = ChangeType.DELETE;
r.add(entry);
- } else {
+ } else if (!entry.oldId.equals(entry.newId)) {
entry.changeType = ChangeType.MODIFY;
if (RenameDetector.sameType(entry.oldMode, entry.newMode))
r.add(entry);
else
r.addAll(breakModify(entry));
}
+
+ if (includeTrees && walk.isSubtree())
+ walk.enterSubtree();
}
return r;
}