mbenson 2005/03/11 11:34:00
Modified: src/main/org/apache/tools/ant Tag: ANT_16_BRANCH
DirectoryScanner.java
Log:
Merge DirectoryScanner improvements;
disable ClasspathUtilsTest if tests.and.ant.share.classloader
PR: 33118
Revision Changes Path
No revision
No revision
1.64.2.10 +593 -362 ant/src/main/org/apache/tools/ant/DirectoryScanner.java
Index: DirectoryScanner.java
===================================================================
RCS file: /home/cvs/ant/src/main/org/apache/tools/ant/DirectoryScanner.java,v
retrieving revision 1.64.2.9
retrieving revision 1.64.2.10
diff -u -r1.64.2.9 -r1.64.2.10
--- DirectoryScanner.java 27 Jan 2005 22:31:54 -0000 1.64.2.9
+++ DirectoryScanner.java 11 Mar 2005 19:34:00 -0000 1.64.2.10
@@ -19,21 +19,22 @@
import java.io.File;
import java.io.IOException;
+import java.util.Map;
+import java.util.Set;
import java.util.Arrays;
-import java.util.Enumeration;
+import java.util.Vector;
import java.util.HashMap;
import java.util.HashSet;
+import java.util.ArrayList;
import java.util.Hashtable;
-import java.util.Map;
-import java.util.Set;
-import java.util.Vector;
+import java.util.Enumeration;
import org.apache.tools.ant.taskdefs.condition.Os;
import org.apache.tools.ant.types.Resource;
import org.apache.tools.ant.types.ResourceFactory;
import org.apache.tools.ant.types.selectors.FileSelector;
-import org.apache.tools.ant.types.selectors.SelectorScanner;
import org.apache.tools.ant.types.selectors.SelectorUtils;
+import org.apache.tools.ant.types.selectors.SelectorScanner;
import org.apache.tools.ant.util.FileUtils;
/**
@@ -164,6 +165,15 @@
"**/.DS_Store"
};
+ /** Helper. */
+ private static final FileUtils FILE_UTILS = FileUtils.getFileUtils();
+
+ /** iterations for case-sensitive scanning. */
+ private static final boolean[] CS_SCAN_ONLY = new boolean[] {true};
+
+ /** iterations for non-case-sensitive scanning. */
+ private static final boolean[] CS_THEN_NON_CS = new boolean[] {true,
false};
+
/**
* Patterns which should be excluded by default.
*
@@ -186,8 +196,9 @@
/** Selectors that will filter which files are in our candidate list. */
protected FileSelector[] selectors = null;
- /** The files which matched at least one include and no excludes
- * and were selected.
+ /**
+ * The files which matched at least one include and no excludes
+ * and were selected.
*/
protected Vector filesIncluded;
@@ -200,8 +211,9 @@
*/
protected Vector filesExcluded;
- /** The directories which matched at least one include and no excludes
- * and were selected.
+ /**
+ * The directories which matched at least one include and no excludes
+ * and were selected.
*/
protected Vector dirsIncluded;
@@ -214,13 +226,15 @@
*/
protected Vector dirsExcluded;
- /** The files which matched at least one include and no excludes and
- * which a selector discarded.
+ /**
+ * The files which matched at least one include and no excludes and
+ * which a selector discarded.
*/
protected Vector filesDeselected;
- /** The directories which matched at least one include and no excludes
- * but which a selector discarded.
+ /**
+ * The directories which matched at least one include and no excludes
+ * but which a selector discarded.
*/
protected Vector dirsDeselected;
@@ -240,20 +254,126 @@
*/
private boolean followSymlinks = true;
- /** Helper. */
- private static final FileUtils FILE_UTILS = FileUtils.newFileUtils();
-
/** Whether or not everything tested so far has been included. */
protected boolean everythingIncluded = true;
/**
+ * Temporary table to speed up the various scanning methods.
+ *
+ * @since Ant 1.6
+ */
+ private Map fileListMap = new HashMap();
+
+ /**
+ * List of all scanned directories.
+ *
+ * @since Ant 1.6
+ */
+ private Set scannedDirs = new HashSet();
+
+ /**
+ * Set of all include patterns that are full file names and don't
+ * contain any wildcards.
+ *
+ * <p>If this instance is not case sensitive, the file names get
+ * turned to lower case.</p>
+ *
+ * <p>Gets lazily initialized on the first invocation of
+ * isIncluded or isExcluded and cleared at the end of the scan
+ * method (cleared in clearCaches, actually).</p>
+ *
+ * @since Ant 1.6.3
+ */
+ private Set includeNonPatterns = new HashSet();
+
+ /**
+ * Set of all include patterns that are full file names and don't
+ * contain any wildcards.
+ *
+ * <p>If this instance is not case sensitive, the file names get
+ * turned to lower case.</p>
+ *
+ * <p>Gets lazily initialized on the first invocation of
+ * isIncluded or isExcluded and cleared at the end of the scan
+ * method (cleared in clearCaches, actually).</p>
+ *
+ * @since Ant 1.6.3
+ */
+ private Set excludeNonPatterns = new HashSet();
+
+ /**
+ * Array of all include patterns that contain wildcards.
+ *
+ * <p>Gets lazily initialized on the first invocation of
+ * isIncluded or isExcluded and cleared at the end of the scan
+ * method (cleared in clearCaches, actually).</p>
+ *
+ * @since Ant 1.6.3
+ */
+ private String[] includePatterns;
+
+ /**
+ * Array of all exclude patterns that contain wildcards.
+ *
+ * <p>Gets lazily initialized on the first invocation of
+ * isIncluded or isExcluded and cleared at the end of the scan
+ * method (cleared in clearCaches, actually).</p>
+ *
+ * @since Ant 1.6.3
+ */
+ private String[] excludePatterns;
+
+ /**
+ * Have the non-pattern sets and pattern arrays for in- and
+ * excludes been initialized?
+ *
+ * @since Ant 1.6.3
+ */
+ private boolean areNonPatternSetsReady = false;
+
+ /**
+ * Scanning flag.
+ *
+ * @since Ant 1.6.3
+ */
+ private boolean scanning = false;
+
+ /**
+ * Scanning lock.
+ *
+ * @since Ant 1.6.3
+ */
+ private Object scanLock = new Object();
+
+ /**
+ * Slow scanning flag.
+ *
+ * @since Ant 1.6.3
+ */
+ private boolean slowScanning = false;
+
+ /**
+ * Slow scanning lock.
+ *
+ * @since Ant 1.6.3
+ */
+ private Object slowScanLock = new Object();
+
+ /**
+ * Exception thrown during scan.
+ *
+ * @since Ant 1.6.3
+ */
+ private IllegalStateException illegal = null;
+
+ /**
* Sole constructor.
*/
public DirectoryScanner() {
}
/**
- * Tests whether or not a given path matches the start of a given
+ * Test whether or not a given path matches the start of a given
* pattern up to the first "**".
* <p>
* This is not a general purpose test and should only be used if you
@@ -271,8 +391,9 @@
protected static boolean matchPatternStart(String pattern, String str) {
return SelectorUtils.matchPatternStart(pattern, str);
}
+
/**
- * Tests whether or not a given path matches the start of a given
+ * Test whether or not a given path matches the start of a given
* pattern up to the first "**".
* <p>
* This is not a general purpose test and should only be used if you
@@ -295,7 +416,7 @@
}
/**
- * Tests whether or not a given path matches a given pattern.
+ * Test whether or not a given path matches a given pattern.
*
* @param pattern The pattern to match against. Must not be
* <code>null</code>.
@@ -310,7 +431,7 @@
}
/**
- * Tests whether or not a given path matches a given pattern.
+ * Test whether or not a given path matches a given pattern.
*
* @param pattern The pattern to match against. Must not be
* <code>null</code>.
@@ -328,7 +449,7 @@
}
/**
- * Tests whether or not a string matches against a pattern.
+ * Test whether or not a string matches against a pattern.
* The pattern may contain two special characters:<br>
* '*' means zero or more characters<br>
* '?' means one and only one character
@@ -346,7 +467,7 @@
}
/**
- * Tests whether or not a string matches against a pattern.
+ * Test whether or not a string matches against a pattern.
* The pattern may contain two special characters:<br>
* '*' means zero or more characters<br>
* '?' means one and only one character
@@ -387,9 +508,8 @@
* default exclude.
*
* @param s A string to add as an exclude pattern.
- * @return <code>true</code> if the string was added
- * <code>false</code> if it already
- * existed.
+ * @return <code>true</code> if the string was added;
+ * <code>false</code> if it already existed.
*
* @since Ant 1.6
*/
@@ -406,9 +526,9 @@
*
* @param s The string to attempt to remove.
* @return <code>true</code> if <code>s</code> was a default
- * exclude (and thus was removed),
+ * exclude (and thus was removed);
* <code>false</code> if <code>s</code> was not
- * in the default excludes list to begin with
+ * in the default excludes list to begin with.
*
* @since Ant 1.6
*/
@@ -417,20 +537,19 @@
}
/**
- * Go back to the hard wired default exclude patterns
+ * Go back to the hardwired default exclude patterns.
*
* @since Ant 1.6
*/
public static void resetDefaultExcludes() {
defaultExcludes = new Vector();
-
for (int i = 0; i < DEFAULTEXCLUDES.length; i++) {
defaultExcludes.add(DEFAULTEXCLUDES[i]);
}
}
/**
- * Sets the base directory to be scanned. This is the directory which is
+ * Set the base directory to be scanned. This is the directory which is
* scanned recursively. All '/' and '\' characters are replaced by
* <code>File.separatorChar</code>, so the separator used need not match
* <code>File.separatorChar</code>.
@@ -444,68 +563,69 @@
}
/**
- * Sets the base directory to be scanned. This is the directory which is
+ * Set the base directory to be scanned. This is the directory which is
* scanned recursively.
*
* @param basedir The base directory for scanning.
* Should not be <code>null</code>.
*/
- public void setBasedir(File basedir) {
+ public synchronized void setBasedir(File basedir) {
this.basedir = basedir;
}
/**
- * Returns the base directory to be scanned.
+ * Return the base directory to be scanned.
* This is the directory which is scanned recursively.
*
* @return the base directory to be scanned
*/
- public File getBasedir() {
+ public synchronized File getBasedir() {
return basedir;
}
/**
* Find out whether include exclude patterns are matched in a
- * case sensitive way
- * @return whether or not the scanning is case sensitive
- * @since ant 1.6
+ * case sensitive way.
+ * @return whether or not the scanning is case sensitive.
+ * @since Ant 1.6
*/
- public boolean isCaseSensitive() {
+ public synchronized boolean isCaseSensitive() {
return isCaseSensitive;
}
+
/**
- * Sets whether or not include and exclude patterns are matched
- * in a case sensitive way
+ * Set whether or not include and exclude patterns are matched
+ * in a case sensitive way.
*
* @param isCaseSensitive whether or not the file system should be
- * regarded as a case sensitive one
+ * regarded as a case sensitive one.
*/
- public void setCaseSensitive(boolean isCaseSensitive) {
+ public synchronized void setCaseSensitive(boolean isCaseSensitive) {
this.isCaseSensitive = isCaseSensitive;
}
/**
- * gets whether or not a DirectoryScanner follows symbolic links
+ * Get whether or not a DirectoryScanner follows symbolic links.
*
- * @return flag indicating whether symbolic links should be followed
+ * @return flag indicating whether symbolic links should be followed.
*
- * @since ant 1.6
+ * @since Ant 1.6
*/
- public boolean isFollowSymlinks() {
+ public synchronized boolean isFollowSymlinks() {
return followSymlinks;
}
/**
- * Sets whether or not symbolic links should be followed.
+ * Set whether or not symbolic links should be followed.
*
- * @param followSymlinks whether or not symbolic links should be followed
+ * @param followSymlinks whether or not symbolic links should be
followed.
*/
- public void setFollowSymlinks(boolean followSymlinks) {
+ public synchronized void setFollowSymlinks(boolean followSymlinks) {
this.followSymlinks = followSymlinks;
}
/**
- * Sets the list of include patterns to use. All '/' and '\' characters
+ * Set the list of include patterns to use. All '/' and '\' characters
* are replaced by <code>File.separatorChar</code>, so the separator used
* need not match <code>File.separatorChar</code>.
* <p>
@@ -515,28 +635,21 @@
* May be <code>null</code>, indicating that all files
* should be included. If a non-<code>null</code>
* list is given, all elements must be
- * non-<code>null</code>.
+ * non-<code>null</code>.
*/
- public void setIncludes(String[] includes) {
+ public synchronized void setIncludes(String[] includes) {
if (includes == null) {
this.includes = null;
} else {
this.includes = new String[includes.length];
for (int i = 0; i < includes.length; i++) {
- String pattern;
- pattern = includes[i].replace('/',
File.separatorChar).replace(
- '\\', File.separatorChar);
- if (pattern.endsWith(File.separator)) {
- pattern += "**";
- }
- this.includes[i] = pattern;
+ this.includes[i] = normalizePattern(includes[i]);
}
}
}
-
/**
- * Sets the list of exclude patterns to use. All '/' and '\' characters
+ * Set the list of exclude patterns to use. All '/' and '\' characters
* are replaced by <code>File.separatorChar</code>, so the separator used
* need not match <code>File.separatorChar</code>.
* <p>
@@ -547,47 +660,88 @@
* should be excluded. If a non-<code>null</code> list is
* given, all elements must be non-<code>null</code>.
*/
- public void setExcludes(String[] excludes) {
+ public synchronized void setExcludes(String[] excludes) {
if (excludes == null) {
this.excludes = null;
} else {
this.excludes = new String[excludes.length];
for (int i = 0; i < excludes.length; i++) {
- String pattern;
- pattern = excludes[i].replace('/',
File.separatorChar).replace(
- '\\', File.separatorChar);
- if (pattern.endsWith(File.separator)) {
- pattern += "**";
+ this.excludes[i] = normalizePattern(excludes[i]);
+ }
+ }
+ }
+
+ /**
+ * Add to the list of exclude patterns to use. All '/' and '\'
+ * characters are replaced by <code>File.separatorChar</code>, so
+ * the separator used need not match <code>File.separatorChar</code>.
+ * <p>
+ * When a pattern ends with a '/' or '\', "**" is appended.
+ *
+ * @param excludes A list of exclude patterns.
+ * May be <code>null</code>, in which case the
+ * exclude patterns don't get changed at all.
+ *
+ * @since Ant 1.6.3
+ */
+ public synchronized void addExcludes(String[] excludes) {
+ if (excludes != null && excludes.length > 0) {
+ if (this.excludes != null && this.excludes.length > 0) {
+ String[] tmp = new String[excludes.length
+ + this.excludes.length];
+ System.arraycopy(this.excludes, 0, tmp, 0,
+ this.excludes.length);
+ for (int i = 0; i < excludes.length; i++) {
+ tmp[this.excludes.length + i] =
+ normalizePattern(excludes[i]);
}
- this.excludes[i] = pattern;
+ this.excludes = tmp;
+ } else {
+ setExcludes(excludes);
}
}
}
+ /**
+ * All '/' and '\' characters are replaced by
+ * <code>File.separatorChar</code>, so the separator used need not
+ * match <code>File.separatorChar</code>.
+ *
+ * <p> When a pattern ends with a '/' or '\', "**" is appended.
+ *
+ * @since Ant 1.6.3
+ */
+ private static String normalizePattern(String p) {
+ String pattern = p.replace('/', File.separatorChar)
+ .replace('\\', File.separatorChar);
+ if (pattern.endsWith(File.separator)) {
+ pattern += "**";
+ }
+ return pattern;
+ }
/**
- * Sets the selectors that will select the filelist.
+ * Set the selectors that will select the filelist.
*
- * @param selectors specifies the selectors to be invoked on a scan
+ * @param selectors specifies the selectors to be invoked on a scan.
*/
- public void setSelectors(FileSelector[] selectors) {
+ public synchronized void setSelectors(FileSelector[] selectors) {
this.selectors = selectors;
}
-
/**
- * Returns whether or not the scanner has included all the files or
+ * Return whether or not the scanner has included all the files or
* directories it has come across so far.
*
* @return <code>true</code> if all files and directories which have
* been found so far have been included.
*/
- public boolean isEverythingIncluded() {
+ public synchronized boolean isEverythingIncluded() {
return everythingIncluded;
}
/**
- * Scans the base directory for files which match at least one include
+ * Scan the base directory for files which match at least one include
* pattern and don't match any exclude patterns. If there are selectors
* then the files must pass muster there, as well.
*
@@ -596,68 +750,87 @@
* or isn't a directory).
*/
public void scan() throws IllegalStateException {
- if (basedir == null) {
- throw new IllegalStateException("No basedir set");
- }
- if (!basedir.exists()) {
- throw new IllegalStateException("basedir " + basedir
- + " does not exist");
- }
- if (!basedir.isDirectory()) {
- throw new IllegalStateException("basedir " + basedir
- + " is not a directory");
- }
-
- if (includes == null) {
- // No includes supplied, so set it to 'matches all'
- includes = new String[1];
- includes[0] = "**";
- }
- if (excludes == null) {
- excludes = new String[0];
+ synchronized (scanLock) {
+ if (scanning) {
+ while (scanning) {
+ try {
+ scanLock.wait();
+ } catch (InterruptedException e) {
+ continue;
+ }
+ }
+ if (illegal != null) {
+ throw illegal;
+ }
+ return;
+ }
+ scanning = true;
}
+ try {
+ synchronized (this) {
+ illegal = null;
+ clearResults();
+
+ // set in/excludes to reasonable defaults if needed:
+ boolean nullIncludes = (includes == null);
+ includes = nullIncludes ? new String[] {"**"} : includes;
+ boolean nullExcludes = (excludes == null);
+ excludes = nullExcludes ? new String[0] : excludes;
- filesIncluded = new Vector();
- filesNotIncluded = new Vector();
- filesExcluded = new Vector();
- filesDeselected = new Vector();
- dirsIncluded = new Vector();
- dirsNotIncluded = new Vector();
- dirsExcluded = new Vector();
- dirsDeselected = new Vector();
-
- if (isIncluded("")) {
- if (!isExcluded("")) {
- if (isSelected("", basedir)) {
- dirsIncluded.addElement("");
+ if (basedir == null) {
+ illegal = new IllegalStateException("No basedir set");
} else {
- dirsDeselected.addElement("");
+ if (!basedir.exists()) {
+ illegal = new IllegalStateException("basedir " +
basedir
+ + " does not exist");
+ }
+ if (!basedir.isDirectory()) {
+ illegal = new IllegalStateException("basedir " +
basedir
+ + " is not a
directory");
+ }
}
- } else {
- dirsExcluded.addElement("");
+ if (illegal != null) {
+ throw illegal;
+ }
+ if (isIncluded("")) {
+ if (!isExcluded("")) {
+ if (isSelected("", basedir)) {
+ dirsIncluded.addElement("");
+ } else {
+ dirsDeselected.addElement("");
+ }
+ } else {
+ dirsExcluded.addElement("");
+ }
+ } else {
+ dirsNotIncluded.addElement("");
+ }
+ checkIncludePatterns();
+ clearCaches();
+ includes = nullIncludes ? null : includes;
+ excludes = nullExcludes ? null : excludes;
+ }
+ } finally {
+ synchronized (scanLock) {
+ scanning = false;
+ scanLock.notifyAll();
}
- } else {
- dirsNotIncluded.addElement("");
}
- checkIncludePatterns();
- clearCaches();
}
/**
- * this routine is actually checking all the include patterns in
- * order to avoid scanning everything under base dir
- * @since ant1.6
+ * This routine is actually checking all the include patterns in
+ * order to avoid scanning everything under base dir.
+ * @since Ant 1.6
*/
private void checkIncludePatterns() {
Hashtable newroots = new Hashtable();
// put in the newroots vector the include patterns without
// wildcard tokens
for (int icounter = 0; icounter < includes.length; icounter++) {
- String newpattern =
- SelectorUtils.rtrimWildcardTokens(includes[icounter]);
- newroots.put(newpattern, includes[icounter]);
+ newroots.put(SelectorUtils.rtrimWildcardTokens(
+ includes[icounter]), includes[icounter]);
}
-
if (newroots.containsKey("")) {
// we are going to scan everything anyway
scandir(basedir, "", true);
@@ -672,7 +845,6 @@
} catch (IOException ex) {
throw new BuildException(ex);
}
-
while (enum2.hasMoreElements()) {
String currentelement = (String) enum2.nextElement();
String originalpattern = (String)
newroots.get(currentelement);
@@ -687,7 +859,7 @@
String path = FILE_UTILS.removeLeadingPath(canonBase,
canonFile);
if (!path.equals(currentelement) || ON_VMS) {
- myfile = findFile(basedir, currentelement);
+ myfile = findFile(basedir, currentelement, true);
if (myfile != null) {
currentelement =
FILE_UTILS.removeLeadingPath(basedir,
@@ -698,9 +870,8 @@
throw new BuildException(ex);
}
}
-
- if ((myfile == null || !myfile.exists()) &&
!isCaseSensitive) {
- File f = findFileCaseInsensitive(basedir,
currentelement);
+ if ((myfile == null || !myfile.exists()) &&
!isCaseSensitive()) {
+ File f = findFile(basedir, currentelement, false);
if (f.exists()) {
// adapt currentelement to the case we've
// actually found
@@ -709,13 +880,11 @@
myfile = f;
}
}
-
if (myfile != null && myfile.exists()) {
if (!followSymlinks
&& isSymlink(basedir, currentelement)) {
continue;
}
-
if (myfile.isDirectory()) {
if (isIncluded(currentelement)
&& currentelement.length() > 0) {
@@ -732,12 +901,10 @@
scandir(myfile, currentelement, true);
}
} else {
- if (isCaseSensitive
- && originalpattern.equals(currentelement)) {
- accountForIncludedFile(currentelement, myfile);
- } else if (!isCaseSensitive
- && originalpattern
- .equalsIgnoreCase(currentelement)) {
+ boolean included = isCaseSensitive()
+ ? originalpattern.equals(currentelement)
+ :
originalpattern.equalsIgnoreCase(currentelement);
+ if (included) {
accountForIncludedFile(currentelement, myfile);
}
}
@@ -747,6 +914,22 @@
}
/**
+ * Clear the result caches for a scan.
+ */
+ protected synchronized void clearResults() {
+ filesIncluded = new Vector();
+ filesNotIncluded = new Vector();
+ filesExcluded = new Vector();
+ filesDeselected = new Vector();
+ dirsIncluded = new Vector();
+ dirsNotIncluded = new Vector();
+ dirsExcluded = new Vector();
+ dirsDeselected = new Vector();
+ everythingIncluded = (basedir != null);
+ scannedDirs.clear();
+ }
+
+ /**
* Top level invocation for a slow scan. A slow scan builds up a full
* list of excluded/included files/directories, whereas a fast scan
* will only have full results for included files, as it ignores
@@ -755,35 +938,54 @@
* Returns immediately if a slow scan has already been completed.
*/
protected void slowScan() {
- if (haveSlowResults) {
- return;
- }
-
- String[] excl = new String[dirsExcluded.size()];
- dirsExcluded.copyInto(excl);
-
- String[] notIncl = new String[dirsNotIncluded.size()];
- dirsNotIncluded.copyInto(notIncl);
-
- for (int i = 0; i < excl.length; i++) {
- if (!couldHoldIncluded(excl[i])) {
- scandir(new File(basedir, excl[i]),
- excl[i] + File.separator, false);
+ synchronized (slowScanLock) {
+ if (haveSlowResults) {
+ return;
}
+ if (slowScanning) {
+ while (slowScanning) {
+ try {
+ slowScanLock.wait();
+ } catch (InterruptedException e) {
+ }
+ }
+ return;
+ }
+ slowScanning = true;
}
+ try {
+ synchronized (this) {
- for (int i = 0; i < notIncl.length; i++) {
- if (!couldHoldIncluded(notIncl[i])) {
- scandir(new File(basedir, notIncl[i]),
- notIncl[i] + File.separator, false);
+ String[] excl = new String[dirsExcluded.size()];
+ dirsExcluded.copyInto(excl);
+
+ String[] notIncl = new String[dirsNotIncluded.size()];
+ dirsNotIncluded.copyInto(notIncl);
+
+ for (int i = 0; i < excl.length; i++) {
+ if (!couldHoldIncluded(excl[i])) {
+ scandir(new File(basedir, excl[i]),
+ excl[i] + File.separator, false);
+ }
+ }
+ for (int i = 0; i < notIncl.length; i++) {
+ if (!couldHoldIncluded(notIncl[i])) {
+ scandir(new File(basedir, notIncl[i]),
+ notIncl[i] + File.separator, false);
+ }
+ }
+ }
+ } finally {
+ synchronized (slowScanLock) {
+ haveSlowResults = true;
+ slowScanning = false;
+ slowScanLock.notifyAll();
}
}
-
- haveSlowResults = true;
}
/**
- * Scans the given directory for files and directories. Found files and
+ * Scan the given directory for files and directories. Found files and
* directories are placed in their respective collections, based on the
* matching of includes, excludes, and the selectors. When a directory
* is found, it is scanned recursively.
@@ -810,7 +1012,6 @@
} else if (!dir.isDirectory()) {
throw new BuildException(dir + " is not a directory.");
}
-
// avoid double scanning of directories, can only happen in fast mode
if (fast && hasBeenScanned(vpath)) {
return;
@@ -828,19 +1029,15 @@
throw new BuildException("IO error scanning directory "
+ dir.getAbsolutePath());
}
-
if (!followSymlinks) {
Vector noLinks = new Vector();
for (int i = 0; i < newfiles.length; i++) {
try {
if (FILE_UTILS.isSymbolicLink(dir, newfiles[i])) {
String name = vpath + newfiles[i];
- File file = new File(dir, newfiles[i]);
- if (file.isDirectory()) {
- dirsExcluded.addElement(name);
- } else {
- filesExcluded.addElement(name);
- }
+ File file = new File(dir, newfiles[i]);
+ (file.isDirectory()
+ ? dirsExcluded : filesExcluded).addElement(name);
} else {
noLinks.addElement(newfiles[i]);
}
@@ -855,10 +1052,9 @@
newfiles = new String[noLinks.size()];
noLinks.copyInto(newfiles);
}
-
for (int i = 0; i < newfiles.length; i++) {
String name = vpath + newfiles[i];
- File file = new File(dir, newfiles[i]);
+ File file = new File(dir, newfiles[i]);
if (file.isDirectory()) {
if (isIncluded(name)) {
accountForIncludedDir(name, file, fast);
@@ -882,67 +1078,60 @@
}
}
}
+
/**
- * process included file
- * @param name path of the file relative to the directory of the fileset
- * @param file included file
+ * Process included file.
+ * @param name path of the file relative to the directory of the
FileSet.
+ * @param file included File.
*/
private void accountForIncludedFile(String name, File file) {
- if (!filesIncluded.contains(name)
- && !filesExcluded.contains(name)
- && !filesDeselected.contains(name)) {
-
- if (!isExcluded(name)) {
- if (isSelected(name, file)) {
- filesIncluded.addElement(name);
- } else {
- everythingIncluded = false;
- filesDeselected.addElement(name);
- }
- } else {
- everythingIncluded = false;
- filesExcluded.addElement(name);
- }
+ if (filesIncluded.contains(name)
+ || filesExcluded.contains(name)
+ || filesDeselected.contains(name)) {
+ return;
}
+ boolean included = false;
+ if (isExcluded(name)) {
+ filesExcluded.addElement(name);
+ } else if (isSelected(name, file)) {
+ included = true;
+ filesIncluded.addElement(name);
+ } else {
+ filesDeselected.addElement(name);
+ }
+ everythingIncluded &= included;
}
/**
- *
+ * Process included directory.
* @param name path of the directory relative to the directory of
- * the fileset
- * @param file directory as file
- * @param fast
+ * the FileSet.
+ * @param file directory as File.
+ * @param fast whether to perform fast scans.
*/
private void accountForIncludedDir(String name, File file, boolean fast)
{
- if (!dirsIncluded.contains(name)
- && !dirsExcluded.contains(name)
- && !dirsDeselected.contains(name)) {
-
- if (!isExcluded(name)) {
- if (isSelected(name, file)) {
- dirsIncluded.addElement(name);
- if (fast) {
- scandir(file, name + File.separator, fast);
- }
- } else {
- everythingIncluded = false;
- dirsDeselected.addElement(name);
- if (fast && couldHoldIncluded(name)) {
- scandir(file, name + File.separator, fast);
- }
- }
-
- } else {
- everythingIncluded = false;
- dirsExcluded.addElement(name);
- if (fast && couldHoldIncluded(name)) {
- scandir(file, name + File.separator, fast);
- }
- }
+ if (dirsIncluded.contains(name)
+ || dirsExcluded.contains(name)
+ || dirsDeselected.contains(name)) {
+ return;
+ }
+ boolean included = false;
+ if (isExcluded(name)) {
+ dirsExcluded.addElement(name);
+ } else if (isSelected(name, file)) {
+ included = true;
+ dirsIncluded.addElement(name);
+ } else {
+ dirsDeselected.addElement(name);
+ }
+ everythingIncluded &= included;
+ if (fast && couldHoldIncluded(name) && !contentsExcluded(name)) {
+ scandir(file, name + File.separator, fast);
}
}
+
/**
- * Tests whether or not a name matches against at least one include
+ * Test whether or not a name matches against at least one include
* pattern.
*
* @param name The name to match. Must not be <code>null</code>.
@@ -950,8 +1139,15 @@
* include pattern, or <code>false</code> otherwise.
*/
protected boolean isIncluded(String name) {
- for (int i = 0; i < includes.length; i++) {
- if (matchPath(includes[i], name, isCaseSensitive)) {
+ ensureNonPatternSetsReady();
+
+ if (isCaseSensitive()
+ ? includeNonPatterns.contains(name)
+ : includeNonPatterns.contains(name.toUpperCase())) {
+ return true;
+ }
+ for (int i = 0; i < includePatterns.length; i++) {
+ if (matchPath(includePatterns[i], name, isCaseSensitive())) {
return true;
}
}
@@ -959,7 +1155,7 @@
}
/**
- * Tests whether or not a name matches the start of at least one include
+ * Test whether or not a name matches the start of at least one include
* pattern.
*
* @param name The name to match. Must not be <code>null</code>.
@@ -968,30 +1164,44 @@
*/
protected boolean couldHoldIncluded(String name) {
for (int i = 0; i < includes.length; i++) {
- if (matchPatternStart(includes[i], name, isCaseSensitive)) {
- if (isMorePowerfulThanExcludes(name, includes[i])) {
- return true;
- }
+ if (matchPatternStart(includes[i], name, isCaseSensitive())
+ && isMorePowerfulThanExcludes(name, includes[i])
+ && isDeeper(includes[i], name)) {
+ return true;
}
}
return false;
}
/**
- * find out whether one particular include pattern is more powerful
- * than all the excludes
- * note : the power comparison is based on the length of the include
pattern
- * and of the exclude patterns without the wildcards
- * ideally the comparison should be done based on the depth
- * of the match, that is to say how many file separators have been
matched
- * before the first ** or the end of the pattern
- *
- * IMPORTANT : this function should return false "with care"
- *
- * @param name the relative path that one want to test
- * @param includepattern one include pattern
- * @return true if there is no exclude pattern more powerful than this
include pattern
- * @since ant1.6
+ * Verify that a pattern specifies files deeper
+ * than the level of the specified file.
+ * @param pattern the pattern to check.
+ * @param name the name to check.
+ * @return whether the pattern is deeper than the name.
+ * @since Ant 1.6.3
+ */
+ private boolean isDeeper(String pattern, String name) {
+ Vector p = SelectorUtils.tokenizePath(pattern);
+ Vector n = SelectorUtils.tokenizePath(name);
+ return p.contains("**") || p.size() > n.size();
+ }
+
+ /**
+ * Find out whether one particular include pattern is more powerful
+ * than all the excludes.
+ * Note: the power comparison is based on the length of the include
pattern
+ * and of the exclude patterns without the wildcards.
+ * Ideally the comparison should be done based on the depth
+ * of the match; that is to say how many file separators have been
matched
+ * before the first ** or the end of the pattern.
+ *
+ * IMPORTANT : this function should return false "with care".
+ *
+ * @param name the relative path to test.
+ * @param includepattern one include pattern.
+ * @return true if there is no exclude pattern more powerful than this
include pattern.
+ * @since Ant 1.6
*/
private boolean isMorePowerfulThanExcludes(String name, String
includepattern) {
String soughtexclude = name + File.separator + "**";
@@ -1002,8 +1212,26 @@
}
return true;
}
+
+ /**
+ * Test whether all contents of the specified directory must be excluded.
+ * @param name the directory name to check.
+ * @return whether all the specified directory's contents are excluded.
+ */
+ private boolean contentsExcluded(String name) {
+ name = (name.endsWith(File.separator)) ? name : name +
File.separator;
+ for (int i = 0; i < excludes.length; i++) {
+ String e = excludes[i];
+ if (e.endsWith("**") && SelectorUtils.matchPath(
+ e.substring(0, e.length() - 2), name, isCaseSensitive())) {
+ return true;
+ }
+ }
+ return false;
+ }
+
/**
- * Tests whether or not a name matches against at least one exclude
+ * Test whether or not a name matches against at least one exclude
* pattern.
*
* @param name The name to match. Must not be <code>null</code>.
@@ -1011,8 +1239,15 @@
* exclude pattern, or <code>false</code> otherwise.
*/
protected boolean isExcluded(String name) {
- for (int i = 0; i < excludes.length; i++) {
- if (matchPath(excludes[i], name, isCaseSensitive)) {
+ ensureNonPatternSetsReady();
+
+ if (isCaseSensitive()
+ ? excludeNonPatterns.contains(name)
+ : excludeNonPatterns.contains(name.toUpperCase())) {
+ return true;
+ }
+ for (int i = 0; i < excludePatterns.length; i++) {
+ if (matchPath(excludePatterns[i], name, isCaseSensitive())) {
return true;
}
}
@@ -1020,10 +1255,10 @@
}
/**
- * Tests whether a name should be selected.
+ * Test whether a file should be selected.
*
- * @param name the filename to check for selecting
- * @param file the java.io.File object for this filename
+ * @param name the filename to check for selecting.
+ * @param file the java.io.File object for this filename.
* @return <code>false</code> when the selectors says that the file
* should not be selected, <code>true</code> otherwise.
*/
@@ -1039,14 +1274,17 @@
}
/**
- * Returns the names of the files which matched at least one of the
+ * Return the names of the files which matched at least one of the
* include patterns and none of the exclude patterns.
* The names are relative to the base directory.
*
* @return the names of the files which matched at least one of the
* include patterns and none of the exclude patterns.
*/
- public String[] getIncludedFiles() {
+ public synchronized String[] getIncludedFiles() {
+ if (filesIncluded == null) {
+ throw new IllegalStateException();
+ }
String[] files = new String[filesIncluded.size()];
filesIncluded.copyInto(files);
Arrays.sort(files);
@@ -1055,10 +1293,10 @@
/**
* Return the count of included files.
- * @return <CODE>int</CODE>.
+ * @return <code>int</code>.
* @since Ant 1.6.3
*/
- public int getIncludedFilesCount() {
+ public synchronized int getIncludedFilesCount() {
if (filesIncluded == null) {
throw new IllegalStateException();
}
@@ -1066,7 +1304,7 @@
}
/**
- * Returns the names of the files which matched none of the include
+ * Return the names of the files which matched none of the include
* patterns. The names are relative to the base directory. This involves
* performing a slow scan if one has not already been completed.
*
@@ -1075,7 +1313,7 @@
*
* @see #slowScan
*/
- public String[] getNotIncludedFiles() {
+ public synchronized String[] getNotIncludedFiles() {
slowScan();
String[] files = new String[filesNotIncluded.size()];
filesNotIncluded.copyInto(files);
@@ -1083,7 +1321,7 @@
}
/**
- * Returns the names of the files which matched at least one of the
+ * Return the names of the files which matched at least one of the
* include patterns and at least one of the exclude patterns.
* The names are relative to the base directory. This involves
* performing a slow scan if one has not already been completed.
@@ -1093,7 +1331,7 @@
*
* @see #slowScan
*/
- public String[] getExcludedFiles() {
+ public synchronized String[] getExcludedFiles() {
slowScan();
String[] files = new String[filesExcluded.size()];
filesExcluded.copyInto(files);
@@ -1101,7 +1339,7 @@
}
/**
- * <p>Returns the names of the files which were selected out and
+ * <p>Return the names of the files which were selected out and
* therefore not ultimately included.</p>
*
* <p>The names are relative to the base directory. This involves
@@ -1111,7 +1349,7 @@
*
* @see #slowScan
*/
- public String[] getDeselectedFiles() {
+ public synchronized String[] getDeselectedFiles() {
slowScan();
String[] files = new String[filesDeselected.size()];
filesDeselected.copyInto(files);
@@ -1119,14 +1357,17 @@
}
/**
- * Returns the names of the directories which matched at least one of the
+ * Return the names of the directories which matched at least one of the
* include patterns and none of the exclude patterns.
* The names are relative to the base directory.
*
* @return the names of the directories which matched at least one of the
* include patterns and none of the exclude patterns.
*/
- public String[] getIncludedDirectories() {
+ public synchronized String[] getIncludedDirectories() {
+ if (dirsIncluded == null) {
+ throw new IllegalStateException();
+ }
String[] directories = new String[dirsIncluded.size()];
dirsIncluded.copyInto(directories);
Arrays.sort(directories);
@@ -1135,10 +1376,10 @@
/**
* Return the count of included directories.
- * @return <CODE>int</CODE>.
+ * @return <code>int</code>.
* @since Ant 1.6.3
*/
- public int getIncludedDirsCount() {
+ public synchronized int getIncludedDirsCount() {
if (dirsIncluded == null) {
throw new IllegalStateException();
}
@@ -1146,7 +1387,7 @@
}
/**
- * Returns the names of the directories which matched none of the include
+ * Return the names of the directories which matched none of the include
* patterns. The names are relative to the base directory. This involves
* performing a slow scan if one has not already been completed.
*
@@ -1155,7 +1396,7 @@
*
* @see #slowScan
*/
- public String[] getNotIncludedDirectories() {
+ public synchronized String[] getNotIncludedDirectories() {
slowScan();
String[] directories = new String[dirsNotIncluded.size()];
dirsNotIncluded.copyInto(directories);
@@ -1163,7 +1404,7 @@
}
/**
- * Returns the names of the directories which matched at least one of the
+ * Return the names of the directories which matched at least one of the
* include patterns and at least one of the exclude patterns.
* The names are relative to the base directory. This involves
* performing a slow scan if one has not already been completed.
@@ -1173,7 +1414,7 @@
*
* @see #slowScan
*/
- public String[] getExcludedDirectories() {
+ public synchronized String[] getExcludedDirectories() {
slowScan();
String[] directories = new String[dirsExcluded.size()];
dirsExcluded.copyInto(directories);
@@ -1181,7 +1422,7 @@
}
/**
- * <p>Returns the names of the directories which were selected out and
+ * <p>Return the names of the directories which were selected out and
* therefore not ultimately included.</p>
*
* <p>The names are relative to the base directory. This involves
@@ -1191,7 +1432,7 @@
*
* @see #slowScan
*/
- public String[] getDeselectedDirectories() {
+ public synchronized String[] getDeselectedDirectories() {
slowScan();
String[] directories = new String[dirsDeselected.size()];
dirsDeselected.copyInto(directories);
@@ -1199,9 +1440,9 @@
}
/**
- * Adds default exclusions to the current exclusions set.
+ * Add default exclusions to the current exclusions set.
*/
- public void addDefaultExcludes() {
+ public synchronized void addDefaultExcludes() {
int excludesLength = excludes == null ? 0 : excludes.length;
String[] newExcludes;
newExcludes = new String[excludesLength + defaultExcludes.size()];
@@ -1218,29 +1459,23 @@
}
/**
- * Get the named resource
+ * Get the named resource.
* @param name path name of the file relative to the dir attribute.
*
* @return the resource with the given name.
* @since Ant 1.5.2
*/
- public Resource getResource(String name) {
+ public synchronized Resource getResource(String name) {
File f = FILE_UTILS.resolveFile(basedir, name);
return new Resource(name, f.exists(), f.lastModified(),
f.isDirectory(), f.length());
}
/**
- * temporary table to speed up the various scanning methods below
- *
- * @since Ant 1.6
- */
- private Map fileListMap = new HashMap();
-
- /**
- * Returns a cached result of list performed on file, if
+ * Return a cached result of list performed on file, if
* available. Invokes the method and caches the result otherwise.
*
+ * @param file File (dir) to list.
* @since Ant 1.6
*/
private String[] list(File file) {
@@ -1255,97 +1490,51 @@
}
/**
- * From <code>base</code> traverse the filesystem in a case
- * insensitive manner in order to find a file that matches the
- * given name.
- *
- * @return File object that points to the file in question. if it
- * hasn't been found it will simply be <code>new File(base,
- * path)</code>.
- *
- * @since Ant 1.6
- */
- private File findFileCaseInsensitive(File base, String path) {
- File f = findFileCaseInsensitive(base,
- SelectorUtils.tokenizePath(path));
- return f == null ? new File(base, path) : f;
- }
-
- /**
- * From <code>base</code> traverse the filesystem in a case
- * insensitive manner in order to find a file that matches the
- * given stack of names.
- *
- * @return File object that points to the file in question or null.
- *
- * @since Ant 1.6
- */
- private File findFileCaseInsensitive(File base, Vector pathElements) {
- if (pathElements.size() == 0) {
- return base;
- } else {
- if (!base.isDirectory()) {
- return null;
- }
- String[] files = list(base);
- if (files == null) {
- throw new BuildException("IO error scanning directory "
- + base.getAbsolutePath());
- }
- String current = (String) pathElements.remove(0);
- for (int i = 0; i < files.length; i++) {
- if (files[i].equals(current)) {
- base = new File(base, files[i]);
- return findFileCaseInsensitive(base, pathElements);
- }
- }
- for (int i = 0; i < files.length; i++) {
- if (files[i].equalsIgnoreCase(current)) {
- base = new File(base, files[i]);
- return findFileCaseInsensitive(base, pathElements);
- }
- }
- }
- return null;
- }
-
- /**
* From <code>base</code> traverse the filesystem in order to find
* a file that matches the given name.
*
+ * @param base base File (dir).
+ * @param path file path.
+ * @param cs whether to scan case-sensitively.
* @return File object that points to the file in question or null.
*
- * @since Ant 1.6
+ * @since Ant 1.6.3
*/
- private File findFile(File base, String path) {
- return findFile(base, SelectorUtils.tokenizePath(path));
+ private File findFile(File base, String path, boolean cs) {
+ return findFile(base, SelectorUtils.tokenizePath(path), cs);
}
/**
* From <code>base</code> traverse the filesystem in order to find
* a file that matches the given stack of names.
*
+ * @param base base File (dir).
+ * @param pathElements Vector of path elements (dirs...file).
+ * @param cs whether to scan case-sensitively.
* @return File object that points to the file in question or null.
*
- * @since Ant 1.6
+ * @since Ant 1.6.3
*/
- private File findFile(File base, Vector pathElements) {
+ private File findFile(File base, Vector pathElements, boolean cs) {
if (pathElements.size() == 0) {
return base;
- } else {
- if (!base.isDirectory()) {
- return null;
- }
- String[] files = list(base);
- if (files == null) {
- throw new BuildException("IO error scanning directory "
- + base.getAbsolutePath());
- }
- String current = (String) pathElements.remove(0);
- for (int i = 0; i < files.length; i++) {
- if (files[i].equals(current)) {
- base = new File(base, files[i]);
- return findFile(base, pathElements);
+ }
+ if (!base.isDirectory()) {
+ return null;
+ }
+ String[] files = list(base);
+ if (files == null) {
+ throw new BuildException("IO error scanning directory "
+ + base.getAbsolutePath());
+ }
+ String current = (String) pathElements.remove(0);
+
+ boolean[] matchCase = cs ? CS_SCAN_ONLY : CS_THEN_NON_CS;
+ for (int i = 0; i < matchCase.length; i++) {
+ for (int j = 0; j < files.length; j++) {
+ if (matchCase[i] ? files[j].equals(current)
+ : files[j].equalsIgnoreCase(current)) {
+ return findFile(new File(base, files[j]), pathElements,
cs);
}
}
}
@@ -1355,6 +1544,8 @@
/**
* Do we have to traverse a symlink when trying to reach path from
* basedir?
+ * @param base base File (dir).
+ * @param path file path.
* @since Ant 1.6
*/
private boolean isSymlink(File base, String path) {
@@ -1364,37 +1555,27 @@
/**
* Do we have to traverse a symlink when trying to reach path from
* basedir?
+ * @param base base File (dir).
+ * @param pathElements Vector of path elements (dirs...file).
* @since Ant 1.6
*/
private boolean isSymlink(File base, Vector pathElements) {
if (pathElements.size() > 0) {
String current = (String) pathElements.remove(0);
try {
- if (FILE_UTILS.isSymbolicLink(base, current)) {
- return true;
- } else {
- base = new File(base, current);
- return isSymlink(base, pathElements);
- }
+ return FILE_UTILS.isSymbolicLink(base, current)
+ || isSymlink(new File(base, current), pathElements);
} catch (IOException ioe) {
String msg = "IOException caught while checking "
+ "for links, couldn't get canonical path!";
// will be caught and redirected to Ant's logging system
System.err.println(msg);
- return false;
}
}
return false;
}
/**
- * List of all scanned directories.
- *
- * @since Ant 1.6
- */
- private Set scannedDirs = new HashSet();
-
- /**
* Has the directory with the given path relative to the base
* directory already been scanned?
*
@@ -1407,12 +1588,62 @@
}
/**
+ * This method is of interest for testing purposes. The returned
+ * Set is live and should not be modified.
+ * @return the Set of relative directory names that have been scanned.
+ */
+ /* package-private */ Set getScannedDirs() {
+ return scannedDirs;
+ }
+
+ /**
* Clear internal caches.
*
* @since Ant 1.6
*/
- private void clearCaches() {
+ private synchronized void clearCaches() {
fileListMap.clear();
- scannedDirs.clear();
+ includeNonPatterns.clear();
+ excludeNonPatterns.clear();
+ includePatterns = null;
+ excludePatterns = null;
+ areNonPatternSetsReady = false;
+ }
+
+ /**
+ * Ensure that the in|exclude "patterns"
+ * have been properly divided up.
+ *
+ * @since Ant 1.6.3
+ */
+ private synchronized void ensureNonPatternSetsReady() {
+ if (!areNonPatternSetsReady) {
+ includePatterns = fillNonPatternSet(includeNonPatterns,
includes);
+ excludePatterns = fillNonPatternSet(excludeNonPatterns,
excludes);
+ areNonPatternSetsReady = true;
+ }
}
+
+ /**
+ * Add all patterns that are not real patterns (do not contain
+ * wildcards) to the set and returns the real patterns.
+ *
+ * @param set Set to populate.
+ * @param patterns String[] of patterns.
+ * @since Ant 1.6.3
+ */
+ private String[] fillNonPatternSet(Set set, String[] patterns) {
+ ArrayList al = new ArrayList(patterns.length);
+ for (int i = 0; i < patterns.length; i++) {
+ if (!SelectorUtils.hasWildcards(patterns[i])) {
+ set.add(isCaseSensitive() ? patterns[i]
+ : patterns[i].toUpperCase());
+ } else {
+ al.add(patterns[i]);
+ }
+ }
+ return set.size() == 0 ? patterns
+ : (String[]) al.toArray(new String[al.size()]);
+ }
+
}
---------------------------------------------------------------------
To unsubscribe, e-mail: [EMAIL PROTECTED]
For additional commands, e-mail: [EMAIL PROTECTED]
