From 5213f6e2e8be5495c7a57617adca0e30592d59b7 Mon Sep 17 00:00:00 2001 From: Robin Rosenberg Date: Fri, 4 Jan 2013 00:24:48 +0100 Subject: [PATCH] Define a tree filter for user-visible changes between two indexes The primary purpose of the filter is to detect an index change that could possibly lead to a change in what files are visible in the staging view and decorations. Besides what TreeFilter.ANY_DIFF does for trees in general, this filter also looks at the assume-valid (CE_VALID) flag to see whether changes should be ignored or not. Change-Id: I13e9ed4ae62dc3851204fba598239edce07ca977 --- .../filter/InterIndexDiffFilterTest.java | 199 ++++++++++++++++++ .../treewalk/filter/InterIndexDiffFilter.java | 105 +++++++++ 2 files changed, 304 insertions(+) create mode 100644 org.eclipse.jgit.test/tst/org/eclipse/jgit/treewalk/filter/InterIndexDiffFilterTest.java create mode 100644 org.eclipse.jgit/src/org/eclipse/jgit/treewalk/filter/InterIndexDiffFilter.java diff --git a/org.eclipse.jgit.test/tst/org/eclipse/jgit/treewalk/filter/InterIndexDiffFilterTest.java b/org.eclipse.jgit.test/tst/org/eclipse/jgit/treewalk/filter/InterIndexDiffFilterTest.java new file mode 100644 index 000000000..13fe42687 --- /dev/null +++ b/org.eclipse.jgit.test/tst/org/eclipse/jgit/treewalk/filter/InterIndexDiffFilterTest.java @@ -0,0 +1,199 @@ +/* + * Copyright (C) 2013, Robin Rosenberg + * 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.treewalk.filter; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertTrue; + +import java.io.IOException; + +import org.eclipse.jgit.dircache.DirCache; +import org.eclipse.jgit.dircache.DirCacheEditor; +import org.eclipse.jgit.dircache.DirCacheEntry; +import org.eclipse.jgit.dircache.DirCacheIterator; +import org.eclipse.jgit.dircache.DirCacheEditor.PathEdit; +import org.eclipse.jgit.junit.LocalDiskRepositoryTestCase; +import org.eclipse.jgit.lib.Constants; +import org.eclipse.jgit.lib.FileMode; +import org.eclipse.jgit.lib.ObjectId; +import org.eclipse.jgit.storage.file.FileRepository; +import org.eclipse.jgit.treewalk.TreeWalk; +import org.junit.Before; +import org.junit.Test; + +public class InterIndexDiffFilterTest extends LocalDiskRepositoryTestCase { + + private FileRepository db; + + @Before + public void setUp() throws Exception { + super.setUp(); + db = createWorkRepository(); + } + + @Test + public void testEmpty() throws IOException { + DirCache dc1 = DirCache.newInCore(); + DirCache dc2 = DirCache.newInCore(); + TreeWalk tw = new TreeWalk(db); + tw.addTree(new DirCacheIterator(dc1)); + tw.addTree(new DirCacheIterator(dc2)); + assertFalse(tw.next()); + } + + static final class AddEdit extends PathEdit { + + private final ObjectId data; + + private final long length; + + private boolean assumeValid; + + private FileMode type; + + public AddEdit(String entryPath, FileMode type, ObjectId data, + long length, + boolean assumeValid) { + super(entryPath); + this.type = type; + this.data = data; + this.length = length; + this.assumeValid = assumeValid; + } + + @Override + public void apply(DirCacheEntry ent) { + ent.setFileMode(type); + ent.setLength(length); + ent.setObjectId(data); + ent.setAssumeValid(assumeValid); + } + } + + private ObjectId id(String data) { + byte[] bytes = data.getBytes(); + return db.newObjectInserter().idFor(Constants.OBJ_BLOB, bytes); + } + + @Test + public void testOneOnly() throws IOException { + DirCache dc1 = DirCache.newInCore(); + DirCache dc2 = DirCache.newInCore(); + DirCacheEditor editor = dc1.editor(); + editor.add(new AddEdit("a/a", FileMode.REGULAR_FILE, id("a"), 1, false)); + editor.finish(); + + TreeWalk tw = new TreeWalk(db); + tw.setRecursive(true); + tw.addTree(new DirCacheIterator(dc1)); + tw.addTree(new DirCacheIterator(dc2)); + tw.setFilter(InterIndexDiffFilter.INSTANCE); + assertTrue(tw.next()); + assertEquals("a/a", tw.getPathString()); + assertFalse(tw.next()); + } + + @Test + public void testTwoSame() throws IOException { + DirCache dc1 = DirCache.newInCore(); + DirCache dc2 = DirCache.newInCore(); + DirCacheEditor ed1 = dc1.editor(); + ed1.add(new AddEdit("a/a", FileMode.REGULAR_FILE, id("a"), 1, false)); + ed1.finish(); + DirCacheEditor ed2 = dc2.editor(); + ed2.add(new AddEdit("a/a", FileMode.REGULAR_FILE, id("a"), 1, false)); + ed2.finish(); + + TreeWalk tw = new TreeWalk(db); + tw.setRecursive(true); + tw.addTree(new DirCacheIterator(dc1)); + tw.addTree(new DirCacheIterator(dc2)); + tw.setFilter(InterIndexDiffFilter.INSTANCE); + + assertFalse(tw.next()); + } + + @Test + public void testTwoSameDifferByAssumeValid() throws IOException { + DirCache dc1 = DirCache.newInCore(); + DirCache dc2 = DirCache.newInCore(); + DirCacheEditor ed1 = dc1.editor(); + ed1.add(new AddEdit("a/a", FileMode.REGULAR_FILE, id("a"), 1, false)); + ed1.finish(); + DirCacheEditor ed2 = dc2.editor(); + ed2.add(new AddEdit("a/a", FileMode.REGULAR_FILE, id("a"), 1, true)); + ed2.finish(); + + TreeWalk tw = new TreeWalk(db); + tw.setRecursive(true); + tw.addTree(new DirCacheIterator(dc1)); + tw.addTree(new DirCacheIterator(dc2)); + tw.setFilter(InterIndexDiffFilter.INSTANCE); + + assertTrue(tw.next()); + assertEquals("a/a", tw.getPathString()); + assertFalse(tw.next()); + } + + @Test + public void testTwoSameSameAssumeValidDifferentContent() + throws IOException { + DirCache dc1 = DirCache.newInCore(); + DirCache dc2 = DirCache.newInCore(); + DirCacheEditor ed1 = dc1.editor(); + ed1.add(new AddEdit("a/a", FileMode.REGULAR_FILE, id("a"), 1, true)); + ed1.finish(); + DirCacheEditor ed2 = dc2.editor(); + ed2.add(new AddEdit("a/a", FileMode.REGULAR_FILE, id("b"), 1, true)); + ed2.finish(); + + TreeWalk tw = new TreeWalk(db); + tw.setRecursive(true); + tw.addTree(new DirCacheIterator(dc1)); + tw.addTree(new DirCacheIterator(dc2)); + tw.setFilter(InterIndexDiffFilter.INSTANCE); + + assertFalse(tw.next()); + } +} diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/treewalk/filter/InterIndexDiffFilter.java b/org.eclipse.jgit/src/org/eclipse/jgit/treewalk/filter/InterIndexDiffFilter.java new file mode 100644 index 000000000..17194162c --- /dev/null +++ b/org.eclipse.jgit/src/org/eclipse/jgit/treewalk/filter/InterIndexDiffFilter.java @@ -0,0 +1,105 @@ +/* + * Copyright (C) 2013, Robin Rosenberg + * 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.treewalk.filter; + +import org.eclipse.jgit.dircache.DirCacheEntry; +import org.eclipse.jgit.dircache.DirCacheIterator; +import org.eclipse.jgit.treewalk.TreeWalk; + +/** + * A filter for extracting changes between two versions of the dircache. In + * addition to what {@link TreeFilter#ANY_DIFF} would do, it also detects + * changes that will affect decorations and show up in an attempt to commit. + */ +public final class InterIndexDiffFilter extends TreeFilter { + private static final int baseTree = 0; + + /** + * Predefined InterIndexDiffFilter for finding changes between two dircaches + */ + public static final TreeFilter INSTANCE = new InterIndexDiffFilter(); + + @Override + public boolean include(final TreeWalk walker) { + final int n = walker.getTreeCount(); + if (n == 1) // Assume they meant difference to empty tree. + return true; + + final int m = walker.getRawMode(baseTree); + for (int i = 1; i < n; i++) { + DirCacheIterator baseDirCache = walker.getTree(baseTree, + DirCacheIterator.class); + DirCacheIterator newDirCache = walker.getTree(i, + DirCacheIterator.class); + if (baseDirCache != null && newDirCache != null) { + DirCacheEntry baseDci = baseDirCache.getDirCacheEntry(); + DirCacheEntry newDci = newDirCache.getDirCacheEntry(); + if (baseDci != null && newDci != null) { + if (baseDci.isAssumeValid() != newDci.isAssumeValid()) + return true; + if (baseDci.isAssumeValid()) // && newDci.isAssumeValid() + return false; + } + } + if (walker.getRawMode(i) != m || !walker.idEqual(i, baseTree)) + return true; + } + return false; + } + + @Override + public boolean shouldBeRecursive() { + return false; + } + + @Override + public TreeFilter clone() { + return this; + } + + @Override + public String toString() { + return "INTERINDEX_DIFF"; //$NON-NLS-1$ + } +} \ No newline at end of file