diff --git a/org.eclipse.jgit.test/META-INF/MANIFEST.MF b/org.eclipse.jgit.test/META-INF/MANIFEST.MF index 85f6c305a..d7f7ef1b6 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 000000000..21069efa5 --- /dev/null +++ b/org.eclipse.jgit.test/tst/org/eclipse/jgit/diff/DiffEntryTest.java @@ -0,0 +1,298 @@ +/* + * Copyright (C) 2011, Dariusz Luksza + * 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 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 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 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 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 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 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 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 8c87d2a6b..9cc0e022e 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 af20477a6..3b645e8dd 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 static JGitText get() { /***/ 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 76d86a999..5bccccfc1 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.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 @@ protected 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 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 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 r = new ArrayList(); MutableObjectId idBuf = new MutableObjectId(); while (walk.next()) { @@ -133,13 +166,16 @@ public static List scan(TreeWalk walk) throws IOException { 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; }