Remove gitIgnoreTimestamp from abstract iterator API

This never should have been exposed on the top of the
AbstractTreeIterator type hierarchy.  There is no concept of a
timestamp in a canonical tree read from the object database, and
the time in the DirCache isn't what we want here either.

Actually all that we need is to find the files whose names are
".gitignore" and are below the root directory.  We can accomplish
that with a suffix filter, and process them immediately.

Change-Id: Ib09cbf81a9e038452ce491385c65498312e2916b
Signed-off-by: Shawn O. Pearce <spearce@spearce.org>
CC: Charley Wang <chwang@redhat.com>
CC: Chris Aniszczyk <caniszczyk@gmail.com>
CC: Stefan Lay <stefan.lay@sap.com>
CC: Matthias Sohn <matthias.sohn@sap.com>

diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/ignore/SimpleIgnoreCache.java b/org.eclipse.jgit/src/org/eclipse/jgit/ignore/SimpleIgnoreCache.java
index be37a9ad8dacff49e7d6fa5b31f00b5375b7f5fe..0d74e881c3c1518106a3d14bf9cd650b59de2872 100644 (file)
--- a/org.eclipse.jgit/src/org/eclipse/jgit/ignore/SimpleIgnoreCache.java
+++ b/org.eclipse.jgit/src/org/eclipse/jgit/ignore/SimpleIgnoreCache.java
@@ -46,11 +46,12 @@ import java.io.File;
 import java.io.IOException;
 import java.net.URI;
 import java.util.HashMap;
-import java.util.HashSet;
 
+import org.eclipse.jgit.lib.Constants;
 import org.eclipse.jgit.lib.Repository;
 import org.eclipse.jgit.treewalk.FileTreeIterator;
 import org.eclipse.jgit.treewalk.TreeWalk;
+import org.eclipse.jgit.treewalk.filter.PathSuffixFilter;
 import org.eclipse.jgit.util.FS;
 
 /**
@@ -112,19 +113,10 @@ public class SimpleIgnoreCache {
                TreeWalk tw = new TreeWalk(repository);
                tw.reset();
                tw.addTree(new FileTreeIterator(repository.getWorkDir(), FS.DETECTED));
+               tw.setFilter(PathSuffixFilter.create("/" + Constants.DOT_GIT_IGNORE));
                tw.setRecursive(true);
-
-               //Don't waste time trying to add iterators that already exist
-               HashSet<FileTreeIterator> toAdd = new HashSet<FileTreeIterator>();
-               while (tw.next()) {
-                       FileTreeIterator t = tw.getTree(0, FileTreeIterator.class);
-                       if (t.hasGitIgnore()) {
-                               toAdd.add(t);
-                               //TODO: Account for and test the removal of .gitignore files
-                       }
-               }
-               for (FileTreeIterator t : toAdd)
-                       addNodeFromTree(t);
+               while (tw.next())
+                       addNodeFromTree(tw.getTree(0, FileTreeIterator.class));
 
                //The base is special
                //TODO: Test alternate locations for GIT_DIR
@@ -153,24 +145,15 @@ public class SimpleIgnoreCache {
        }
 
        /**
-        *      Adds a node located at the FileTreeIterator's root directory.
-        *      <br>
-        *      Will check for the presence of a .gitignore using {@link FileTreeIterator#hasGitIgnore()}.
-        *      If no .gitignore file exists, nothing will be done.
-        *  <br>
-        *  Will check the last time of modification using {@link FileTreeIterator#hasGitIgnore()}.
-        *  If a node already exists and the time stamp has not changed, do nothing.
-        *      <br>
-        *  Note: This can be extended later if necessary to AbstractTreeIterator by using
-        *  byte[] path instead of File directory.
+        * Adds a node located at the FileTreeIterator's current position.
         *
         * @param t
-        *                        AbstractTreeIterator to check for ignore info. The name of the node
-        *                        should be .gitignore
+        *            FileTreeIterator to check for ignore info. The name of the
+        *            entry should be ".gitignore".
         */
        protected void addNodeFromTree(FileTreeIterator t) {
                IgnoreNode n = ignoreMap.get(relativize(t.getDirectory()));
-               long time = t.getGitIgnoreLastModified();
+               long time = t.getEntryLastModified();
                if (n != null) {
                        if (n.getLastModified() == time)
                                //TODO: Test and optimize

diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/treewalk/AbstractTreeIterator.java b/org.eclipse.jgit/src/org/eclipse/jgit/treewalk/AbstractTreeIterator.java
index 178657a42988d3c235a83469f49db0dab8a80a6f..3b68abca99540d6cb408d94d4f047d71b14924cf 100644 (file)
--- a/org.eclipse.jgit/src/org/eclipse/jgit/treewalk/AbstractTreeIterator.java
+++ b/org.eclipse.jgit/src/org/eclipse/jgit/treewalk/AbstractTreeIterator.java
@@ -138,19 +138,11 @@ public abstract class AbstractTreeIterator {
         */
        protected int pathLen;
 
-       /**
-        * Last modified time of the .gitignore file. Greater than 0 if a .gitignore
-        * file exists.
-        *
-        */
-       protected long gitIgnoreTimeStamp;
-
        /** Create a new iterator with no parent. */
        protected AbstractTreeIterator() {
                parent = null;
                path = new byte[DEFAULT_PATH_SIZE];
                pathOffset = 0;
-               gitIgnoreTimeStamp = 0l;
        }
 
        /**
@@ -170,7 +162,6 @@ public abstract class AbstractTreeIterator {
         */
        protected AbstractTreeIterator(final String prefix) {
                parent = null;
-               gitIgnoreTimeStamp = 0l;
 
                if (prefix != null && prefix.length() > 0) {
                        final ByteBuffer b;
@@ -205,7 +196,6 @@ public abstract class AbstractTreeIterator {
         */
        protected AbstractTreeIterator(final byte[] prefix) {
                parent = null;
-               gitIgnoreTimeStamp = 0l;
 
                if (prefix != null && prefix.length > 0) {
                        pathLen = prefix.length;
@@ -230,7 +220,6 @@ public abstract class AbstractTreeIterator {
                parent = p;
                path = p.path;
                pathOffset = p.pathLen + 1;
-               gitIgnoreTimeStamp = 0l;
 
                try {
                        path[pathOffset - 1] = '/';
@@ -261,7 +250,6 @@ public abstract class AbstractTreeIterator {
                parent = p;
                path = childPath;
                pathOffset = childPathOffset;
-               gitIgnoreTimeStamp = 0l;
        }
 
        /**
@@ -605,22 +593,4 @@ public abstract class AbstractTreeIterator {
        public void getName(byte[] buffer, int offset) {
                System.arraycopy(path, pathOffset, buffer, offset, pathLen - pathOffset);
        }
-
-       /**
-        * @return
-        *                        True if this iterator encountered a .gitignore file when initializing entries.
-        *                        Checks if the gitIgnoreTimeStamp > 0.
-        */
-       public boolean hasGitIgnore() {
-               return gitIgnoreTimeStamp > 0;
-       }
-
-       /**
-        * @return
-        *                        Last modified time of the .gitignore file, if any. Will be > 0 if a .gitignore
-        *                        exists.
-        */
-       public long getGitIgnoreLastModified() {
-               return gitIgnoreTimeStamp;
-       }
 }

diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/treewalk/FileTreeIterator.java b/org.eclipse.jgit/src/org/eclipse/jgit/treewalk/FileTreeIterator.java
index aab25ee8052a556ad02bdcadc340ef65f4c892e9..b17d48a5e325ae5582e829869f45af80d4542761 100644 (file)
--- a/org.eclipse.jgit/src/org/eclipse/jgit/treewalk/FileTreeIterator.java
+++ b/org.eclipse.jgit/src/org/eclipse/jgit/treewalk/FileTreeIterator.java
@@ -69,6 +69,7 @@ public class FileTreeIterator extends WorkingTreeIterator {
         *            the root of the repository.
         */
        protected final File directory;
+
        /**
         *  the file system abstraction which will be necessary to
         *            perform certain file system operations.
@@ -117,16 +118,12 @@ public class FileTreeIterator extends WorkingTreeIterator {
        }
 
        private Entry[] entries() {
-               gitIgnoreTimeStamp = 0l;
                final File[] all = directory.listFiles();
                if (all == null)
                        return EOF;
                final Entry[] r = new Entry[all.length];
-               for (int i = 0; i < r.length; i++) {
+               for (int i = 0; i < r.length; i++)
                        r[i] = new FileEntry(all[i], fs);
-                       if (all[i].getName().equals(Constants.DOT_GIT_IGNORE))
-                               gitIgnoreTimeStamp = r[i].getLastModified();
-               }
                return r;
        }