I'm just renaming variables to prevent name hiding and I saw this - is it a bug?

private int[] removeOrphanFiles(Set nonOrphans, File toDir) {
int[] removedCount = new int[] {0, 0};
String[] excls =
(String[]) nonOrphans.toArray(new String[nonOrphans.size() + 1]);
// want to keep toDir itself
excls[nonOrphans.size()] = "";


       DirectoryScanner ds = null;
       if (syncTarget != null) {
           FileSet fs = new FileSet();
           fs.setDir(toDir);
           fs.setCaseSensitive(syncTarget.isCaseSensitive());
           fs.setFollowSymlinks(syncTarget.isFollowSymlinks());

// preserveInTarget would find all files we want to keep,
// but we need to find all that we want to delete - so the
// meaning of all patterns and selectors must be inverted
PatternSet ps = syncTarget.mergePatterns(getProject());
String[] excludes = ps.getExcludePatterns(getProject()); <-- String[] excludes is never read, that's why I saw ...
fs.appendExcludes(ps.getIncludePatterns(getProject())); <-- appendExcludes, using the includes patterns
fs.appendIncludes(ps.getExcludePatterns(getProject()));
fs.setDefaultexcludes(!syncTarget.getDefaultexcludes());


           // selectors are implicitly ANDed in DirectoryScanner.  To
           // revert their logic we wrap them into a <none> selector
           // instead.
           FileSelector[] s = syncTarget.getSelectors(getProject());
           if (s.length > 0) {
               NoneSelector ns = new NoneSelector();
               for (int i = 0; i < s.length; i++) {
                   ns.appendSelector(s[i]);
               }
               fs.appendSelector(ns);
           }
           ds = fs.getDirectoryScanner(getProject());
       } else {
           ds = new DirectoryScanner();
           ds.setBasedir(toDir);
       }
       ds.addExcludes(excls);

       ds.scan();
       String[] files = ds.getIncludedFiles();
       for (int i = 0; i < files.length; i++) {
           File f = new File(toDir, files[i]);
           log("Removing orphan file: " + f, Project.MSG_DEBUG);
           f.delete();
           ++removedCount[1];
       }
       String[] dirs = ds.getIncludedDirectories();
       // ds returns the directories in lexicographic order.
       // iterating through the array backwards means we are deleting
       // leaves before their parent nodes - thus making sure (well,
       // more likely) that the directories are empty when we try to
       // delete them.
       for (int i = dirs.length - 1; i >= 0; --i) {
           File f = new File(toDir, dirs[i]);
           log("Removing orphan directory: " + f, Project.MSG_DEBUG);
           f.delete();
           ++removedCount[0];
       }
       return removedCount;
   }

---------------------------------------------------------------------
To unsubscribe, e-mail: [EMAIL PROTECTED]
For additional commands, e-mail: [EMAIL PROTECTED]



Reply via email to