From 679cab9b3297e550a9ae04b88ba839dc9eb84957 Mon Sep 17 00:00:00 2001 From: Dariusz Luksza Date: Wed, 17 Aug 2011 12:43:35 +0200 Subject: [PATCH] Adds DiffEntry.scan(TreeWalk, boolean) method 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 Signed-off-by: Matthias Sohn --- org.eclipse.jgit.test/META-INF/MANIFEST.MF | 3 +- .../org/eclipse/jgit/diff/DiffEntryTest.java | 298 ++++++++++++++++++ .../org/eclipse/jgit/JGitText.properties | 2 + .../src/org/eclipse/jgit/JGitText.java | 2 + .../src/org/eclipse/jgit/diff/DiffEntry.java | 38 ++- 5 files changed, 341 insertions(+), 2 deletions(-) create mode 100644 org.eclipse.jgit.test/tst/org/eclipse/jgit/diff/DiffEntryTest.java 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 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 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.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 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 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; }