From 57f5357a1ca7f0208c1e7a2ee791e837935d6645 Mon Sep 17 00:00:00 2001
From: Antoine Levy-Lambert <antoine@apache.org>
Date: Tue, 15 Jul 2003 23:19:15 +0000
Subject: [PATCH] Fix the following (remark of Stefan Bodewig on July 15th 2003
 on the dev list) * You go a long way to avoid redundantly adding patterns in
 DirectoryScanner#checkIncludePatterns (the parent check).  If the patterns
 come in reversed, you'll still have duplicate roots, no?  Say a/b/c is added
 before a/b is.  You may avoid this by sorting the include patterns first.

git-svn-id: https://svn.apache.org/repos/asf/ant/core/trunk@274826 13f79535-47bb-0310-9956-ffa450edef68
---
 .../apache/tools/ant/DirectoryScanner.java    | 41 +++++++++++++------
 .../tools/ant/DirectoryScannerTest.java       | 16 ++++++++
 2 files changed, 44 insertions(+), 13 deletions(-)

diff --git a/src/main/org/apache/tools/ant/DirectoryScanner.java b/src/main/org/apache/tools/ant/DirectoryScanner.java
index ac26f6eb6..e23a097d5 100644
--- a/src/main/org/apache/tools/ant/DirectoryScanner.java
+++ b/src/main/org/apache/tools/ant/DirectoryScanner.java
@@ -658,34 +658,49 @@ public class DirectoryScanner
             String newpattern = 
                 SelectorUtils.rtrimWildcardTokens(includes[icounter]);
             // check whether the candidate new pattern has a parent
-            boolean hasParent=false;
+            boolean hasParent = false;
             Enumeration myenum = newroots.keys();
+            // logically, there should be at most one child pattern present
+            // let's use a vector though to be sure
+            Vector vdelete = new Vector();
             while (myenum.hasMoreElements()) {
-                String existingpattern= (String) myenum.nextElement();
+                String existingpattern = (String) myenum.nextElement();
+                // check whether the existing pattern is a child of the new pattern
+                if (existingpattern.length() >= newpattern.length()) {
+                    if (existingpattern.indexOf(newpattern) == 0) {
+                        vdelete.add(existingpattern);
+                    }
+                }
+                // check whether the new pattern is a child of the existing pattern
                 if (existingpattern.length() <= newpattern.length()) {
-                    if (newpattern.indexOf(existingpattern)==0) {
-                        hasParent=true;
+                    if (newpattern.indexOf(existingpattern) == 0) {
+                        hasParent = true;
+                        break;
                     }
                 }
             }
+            // add the new pattern if does not have parents
             if (!hasParent) {
-                newroots.put(newpattern,includes[icounter]);
+                newroots.put(newpattern, includes[icounter]);
+                // remove child patterns
+                for (int icounter2 = 0; icounter2 < vdelete.size(); icounter2++) {
+                    newroots.remove(vdelete.elementAt(icounter2));
+                }
             }
         }
 
         Enumeration enum2 = newroots.keys();
         while (enum2.hasMoreElements()) {
             String currentelement = (String) enum2.nextElement();
-            File myfile=new File(basedir, currentelement);
+            File myfile = new File(basedir, currentelement);
             if (myfile.exists()) {
                 if (myfile.isDirectory()) {
-                    if (isIncluded(currentelement) 
-                        && currentelement.length()>0) {
-                        accountForIncludedDir(currentelement,myfile,true);
+                    if (isIncluded(currentelement)
+                        && currentelement.length() > 0) {
+                        accountForIncludedDir(currentelement, myfile, true);
                     }  else {
                         if (currentelement.length() > 0) {
-                            if (currentelement.charAt(currentelement.length()
-                                                      -1 ) 
+                            if (currentelement.charAt(currentelement.length()-1)
                                 != File.separatorChar) {
                                 currentelement = 
                                     currentelement + File.separatorChar;
@@ -694,10 +709,10 @@ public class DirectoryScanner
                         scandir(myfile, currentelement, true);
                     }
                 } else {
-                    String originalpattern= 
+                    String originalpattern =
                         (String) newroots.get(currentelement);
                     if (originalpattern.equals(currentelement)) {
-                        accountForIncludedFile(currentelement,myfile);
+                        accountForIncludedFile(currentelement, myfile);
                     }
                 }
             }
diff --git a/src/testcases/org/apache/tools/ant/DirectoryScannerTest.java b/src/testcases/org/apache/tools/ant/DirectoryScannerTest.java
index cee7a541a..998b736fa 100644
--- a/src/testcases/org/apache/tools/ant/DirectoryScannerTest.java
+++ b/src/testcases/org/apache/tools/ant/DirectoryScannerTest.java
@@ -133,6 +133,22 @@ public class DirectoryScannerTest extends BuildFileTest {
         ds.scan();
         compareFiles(ds, new String[] {"alpha/beta/beta.xml", "alpha/beta/gamma/gamma.xml"} ,new String[] {"", "alpha", "alpha/beta", "alpha/beta/gamma"});
     }
+    // father and child pattern test
+    public void testOrderOfIncludePatternsIrrelevant() {
+        String [] expectedFiles = {"alpha/beta/beta.xml", "alpha/beta/gamma/gamma.xml"};
+        String [] expectedDirectories = {"alpha/beta", "alpha/beta/gamma" };
+        DirectoryScanner ds = new DirectoryScanner();
+        ds.setBasedir(new File(getProject().getBaseDir(), "tmp"));
+        ds.setIncludes(new String[] {"alpha/be?a/**", "alpha/beta/gamma/"});
+        ds.scan();
+        compareFiles(ds, expectedFiles, expectedDirectories);
+        // redo the test, but the 2 include patterns are inverted
+        ds = new DirectoryScanner();
+        ds.setBasedir(new File(getProject().getBaseDir(), "tmp"));
+        ds.setIncludes(new String[] {"alpha/beta/gamma/", "alpha/be?a/**"});
+        ds.scan();
+        compareFiles(ds, expectedFiles, expectedDirectories);
+    }
     public void tearDown() {
         getProject().executeTarget("cleanup");
     }