org.apache.tools.ant.types.selectors.SelectorUtils Java Examples

private void findStrayThirdPartyBinaries(File dir, String prefix, Set<String> violations, List<String> ignoredPatterns) throws IOException {
    for (String n : findHgControlledFiles(dir)) {
        File f = new File(dir, n);
        if (f.isDirectory()) {
            findStrayThirdPartyBinaries(f, prefix + n + "/", violations, ignoredPatterns);
        } else if (n.matches(".*\\.(jar|zip)")) {
            String path = prefix + n;
            boolean ignored = false;
            for (String pattern : ignoredPatterns) {
                if (SelectorUtils.matchPath(pattern, path)) {
                    ignored = true;
                    break;
                }
            }
            if (!ignored && dir.getName().equals("external") &&
                    new File(new File(dir.getParentFile(), "nbproject"), "project.xml").isFile()) {
                ignored = true;
            }
            if (!ignored) {
                violations.add(path);
            } else {
                //System.err.println("accepted: " + path);
            }
        }
    }
}
 

private void scanForExtraFiles(File d, String prefix, Set<String> files, String cluster, StringBuilder extraFiles) {
    if (prefix.equals("update_tracking/")) {
        return;
    }
    for (String n : d.list()) {
        File f = new File(d, n);
        if (f.getName().equals(".lastModified")) {
            continue;
        }
        if (f.isDirectory()) {
            scanForExtraFiles(f, prefix + n + "/", files, cluster, extraFiles);
        } else {
            String path = prefix + n;
            if ( patterns != null )
                for( String p: patterns.getExcludePatterns(getProject()) ) 
                    if (SelectorUtils.matchPath(p, path)) return;
                
            if (!files.contains(path)) {
                extraFiles.append("\n" + cluster + ": untracked file " + path);
                f.delete();
            }
        }
    }
}
 

protected boolean match( TypePatternSet.Type type, String str, PatternMatchedSection section ) {

    PatternSet patternSet = section.getPatternSet( type );

    if ( patternSet != null ) {

      String[] excludePatterns = patternSet.getExcludePatterns( project );
      if ( null != excludePatterns ) {
        for ( String excludePattern : excludePatterns ) {
          if ( SelectorUtils.match( excludePattern, str ) ) {
            return false;
          }
        }
      }

      String[] includePatterns = patternSet.getIncludePatterns( project );
      if ( null != includePatterns ) {
        for ( String includePattern : includePatterns ) {
          if ( SelectorUtils.match( includePattern, str ) ) {
            return true;
          }
        }
      } else {
        return true; // no include given: include all
      }
    } else {
      return true; // no patternset for type given: include all
    }
    return false; // str wasnt contained in includes / excludes
  }
 

private boolean isSharedSchema(String pathRelativeToRoot) {
    for (String importPattern : importablePatterns) {
        if (SelectorUtils.matchPath(importPattern, pathRelativeToRoot)) {
            return true;
        }
    }
    return false;
}
 

private static boolean isIgnored(
        final String[] patterns,
        final String resource) {
    for (String pattern : patterns) {
        if (SelectorUtils.match(pattern, resource)) {
            return true;
        }
    }
    return false;
}
 

private static boolean matchModule(Project project, PatternSet pattern, String module) {
    for (String p : pattern.getExcludePatterns(project)) {
        if (SelectorUtils.matchPath(p, module)) {
            return true;
        }
    }
    return false;
}
 

private boolean excluded(File f, String prefix) { // #68929
    String pathAbs = f.getAbsolutePath();
    if (!pathAbs.startsWith(prefix)) {
        throw new BuildException("Examined file " + f + " should have a path starting with " + prefix, getLocation());
    }
    // Cannot just call matchPath on the pathAbs because a relative pattern will *never* match an absolute path!
    String path = pathAbs.substring(prefix.length());
    for (String exclude : DirectoryScanner.getDefaultExcludes()) {
        if (SelectorUtils.matchPath(exclude.replace('/', File.separatorChar), path)) {
            return true;
        }
    }
    return false;
}
 

protected String destinationURL(File rootPath, File file, String src, String dest) {
    String trimmedPattern = SelectorUtils.rtrimWildcardTokens(FilenameUtils.separatorsToUnix(src).replace('/', File.separatorChar));
    if (StringUtils.equals(FilenameUtils.separatorsToUnix(trimmedPattern), FilenameUtils.separatorsToUnix(src))) {
        return dest;
    }
    String trimmedPath = removeStart(subtractPath(rootPath, file), FilenameUtils.separatorsToUnix(trimmedPattern));
    if (!StringUtils.startsWith(trimmedPath, "/") && StringUtils.isNotEmpty(trimmedPath)) {
        trimmedPath = "/" + trimmedPath;
    }
    return dest + trimmedPath;
}
 

boolean matches(String path, String glob) {
    String safeGlob = glob.replace('/', File.separatorChar);
    String safePath = path.replace('/', File.separatorChar);
    return SelectorUtils.matchPath(safeGlob, safePath);
}