Java DirectoryScanner.scan方法代码示例

import org.codehaus.plexus.util.DirectoryScanner; //导入方法依赖的package包/类
private String[] getSassDirectories() {
    DirectoryScanner scanner = new DirectoryScanner();
    scanner.setBasedir(sassSourceDirectory);
    scanner.setIncludes(new String[]{"**/sass"});
    scanner.addDefaultExcludes();
    scanner.scan();
    return scanner.getIncludedDirectories();
}
 

import org.codehaus.plexus.util.DirectoryScanner; //导入方法依赖的package包/类
private Stream<File> searchDir(File dir, boolean warnOnBadDir) {
  if (dir == null || !dir.exists() || !dir.isDirectory()) {
    if (warnOnBadDir && dir != null) {
      getLog().warn("Directory does not exist or is not a directory: " + dir);
    }
    return Stream.empty();
  }
  getLog().debug("Adding directory " + dir);
  DirectoryScanner ds = new DirectoryScanner();
  ds.setBasedir(dir);
  ds.setIncludes(includes != null && includes.length > 0 ? includes : DEFAULT_INCLUDES);
  ds.setExcludes(excludes);
  ds.addDefaultExcludes();
  ds.setCaseSensitive(false);
  ds.setFollowSymlinks(false);
  ds.scan();
  return Stream.of(ds.getIncludedFiles()).map(filename -> new File(dir, filename)).parallel();
}
 

import org.codehaus.plexus.util.DirectoryScanner; //导入方法依赖的package包/类
/**
 * Returns a list of filenames that should be copied over to the destination directory.
 *
 * @param resource the resource to be scanned
 * @return the array of filenames, relative to the sourceDir
 */
private String[] getFilesToCopy( Resource resource )
{
    // CHECKSTYLE_OFF: LineLength
    DirectoryScanner scanner = new DirectoryScanner();
    scanner.setBasedir( resource.getDirectory() );
    if ( resource.getIncludes() != null && !resource.getIncludes().isEmpty() )
    {
        scanner.setIncludes( (String[]) resource.getIncludes().toArray( new String[resource.getIncludes().size()] ) );
    }
    else
    {
        scanner.setIncludes( DEFAULT_INCLUDES );
    }
    if ( resource.getExcludes() != null && !resource.getExcludes().isEmpty() )
    {
        scanner.setExcludes( (String[]) resource.getExcludes().toArray( new String[resource.getExcludes().size()] ) );
    }

    scanner.addDefaultExcludes();

    scanner.scan();

    return scanner.getIncludedFiles();
    // CHECKSTYLE_ON: LineLength
}
 

import org.codehaus.plexus.util.DirectoryScanner; //导入方法依赖的package包/类
private void scanDirectory(File directory, BufferedWriter writer) throws IOException {
    if (!directory.exists())
        return;

    final Log log = getLog();
    log.info("scanning source directory '" + directory.getAbsolutePath() + "'");

    DirectoryScanner scanner = new DirectoryScanner();
    scanner.setIncludes(includes);
    scanner.setExcludes(excludes);
    scanner.setBasedir(directory);
    scanner.scan();

    for (String fileName : scanner.getIncludedFiles()) {
        writer.write(fileName);
        writer.newLine();
    }
}
 

import org.codehaus.plexus.util.DirectoryScanner; //导入方法依赖的package包/类
/**
 * Retrieves a list of file names that are in the given directory, possibly filtered by the list of include
 * patterns or exclude patterns
 *
 * @param baseDirectory directory to retrieve file names from
 * @param includes list of patterns to match against for file names to include, can include Ant patterns
 * @param excludes list of patterns to match for excluded file names, can include Ant patterns
 * @return list of file names within the directory that match all given patterns
 */
public static List<String> getDirectoryFileNames(File baseDirectory, String[] includes, String[] excludes) {
    List<String> files = new ArrayList<String>();

    DirectoryScanner scanner = new DirectoryScanner();

    if (includes != null) {
        scanner.setIncludes(includes);
    }

    if (excludes != null) {
        scanner.setExcludes(excludes);
    }

    scanner.setCaseSensitive(false);
    scanner.addDefaultExcludes();
    scanner.setBasedir(baseDirectory);

    scanner.scan();

    for (String includedFilename : scanner.getIncludedFiles()) {
        files.add(includedFilename);
    }

    return files;
}
 

import org.codehaus.plexus.util.DirectoryScanner; //导入方法依赖的package包/类
public static void copyContent( Path basePath, Path destPath, List<String> includes, List<String> excludes,
                                boolean filtering, Function<String, Object> mapper ) {
    DirectoryScanner scanner = new DirectoryScanner();
    scanner.setBasedir( basePath.toFile() );
    scanner.setIncludes( includes.toArray( new String[includes.size()] ) );
    scanner.setExcludes( excludes.toArray( new String[excludes.size()] ) );
    scanner.scan();
    for( String included : scanner.getIncludedFiles() ) {
        Path src = basePath.resolve( included );
        Path dst = destPath.resolve( included );
        if( filtering ) Files.writeString( dst, Strings.substitute( Files.readString( src ), mapper ) );
        else copy( src, Encoding.PLAIN, dst, Encoding.PLAIN );

        if( !Resources.IS_WINDOWS )
            setPosixPermissions( dst, getPosixPermissions( src ) );
    }
}
 

import org.codehaus.plexus.util.DirectoryScanner; //导入方法依赖的package包/类
private void scanForJavaFiles(List<SourceFile> sources, File sourceDirectory) {
	if (!sourceDirectory.exists()) {
		getLog().debug(sourceDirectory.getAbsolutePath() + " is declared but doesn't exist");
		return;
	}

	DirectoryScanner dirScanner = new DirectoryScanner();
	dirScanner.setBasedir(sourceDirectory);
	dirScanner.setIncludes(includes);
	dirScanner.setExcludes(excludes);
	dirScanner.scan();

	for (String includedPath : dirScanner.getIncludedFiles()) {
		if (includedPath.endsWith(".java")) {
			sources.add(new SourceFile(new File(sourceDirectory, includedPath)));
		}
	}
}
 

import org.codehaus.plexus.util.DirectoryScanner; //导入方法依赖的package包/类
@Override
public List<String> getClasses() {
    DirectoryScanner classScanner = new DirectoryScanner();
    String baseDir = getClassDir();
    List<String> ret = new ArrayList<>();

    if(!new File(baseDir).exists()) {
        return ret;
    }
    classScanner.setBasedir(baseDir);
    classScanner.setCaseSensitive(true);
    classScanner.setIncludes(new String[]{"**/*class"});
    classScanner.setExcludes(new String[]{"**/*$*.class"});
    classScanner.scan();

    for(String s: classScanner.getIncludedFiles()){
        ret.add(s.replaceAll("/", ".").replaceAll("\\\\", ".").replaceAll("\\.class",""));
    }
    return ret;
}
 

import org.codehaus.plexus.util.DirectoryScanner; //导入方法依赖的package包/类
@Override
public List<String> getTestClasses() {
    List<String> ret = new ArrayList<>();
    DirectoryScanner scanner = new DirectoryScanner();
    String baseDir = getTestclassDir();
    if(!new File(baseDir).exists()) {
        return ret;
    }
    scanner.setBasedir(baseDir);
    scanner.setCaseSensitive(true);
    scanner.scan();

    for(String s: scanner.getIncludedFiles()){
        ret.add(s.replaceAll("/", ".").replaceAll("\\\\", ".").replaceAll("\\.class",""));
    }
    return ret;
}
 

import org.codehaus.plexus.util.DirectoryScanner; //导入方法依赖的package包/类
/**
 * Scans a single directory
 *
 * @param root Directory to scan
 * @param includes
 * @param excludes
 * @return
 */
public static List<File> scan(File root, String[] includes, String[] excludes) {
	List<File> files = new ArrayList<File>();
	if (!root.exists()) {
		return files;
	}

	final DirectoryScanner directoryScanner = new DirectoryScanner();
	directoryScanner.setIncludes(includes);
	directoryScanner.setExcludes(excludes);
	directoryScanner.setBasedir(root);
	directoryScanner.scan();

	for (final String fileName : directoryScanner.getIncludedFiles()) {
		files.add(new File(root, fileName));
	}

	return files;
}
 

import org.codehaus.plexus.util.DirectoryScanner; //导入方法依赖的package包/类
private String[] includesFiles(File baseDir, String[] excludes) {
	DirectoryScanner dirScanner = new DirectoryScanner();
	dirScanner.setBasedir(baseDir);

	if (excludes != null) {
		dirScanner.setExcludes(excludes);
	}

	dirScanner.addDefaultExcludes();
	dirScanner.scan();

	final String[] includedFiles = dirScanner.getIncludedFiles();

	// ? dont know why we need this

	for (int i = 0; i < includedFiles.length; i++) {
		includedFiles[i] =
			"/" + includedFiles[i].replace(File.separator, "/");
	}

	return includedFiles;
}
 

import org.codehaus.plexus.util.DirectoryScanner; //导入方法依赖的package包/类
/**
 * Scans a single source dir for sources and includes only the files whose name match the patterns in
 * sourceIncludes and excludes all files whose names match the patterns in sourceExcludes
 * @param sourceDir The directory to scan
 * @param sourceIncludes Only include a file if its name matches a pattern in sourceIncludes
 * @param sourceExcludes Exclude a file if its name matches a pattern in sourceExcludes
 * @return A set of filepath strings
 */
private static String[] scanForSources(final File sourceDir, final Set<String> sourceIncludes,
                                       final Set<String> sourceExcludes) {
    final DirectoryScanner ds = new DirectoryScanner();
    ds.setFollowSymlinks( true );
    ds.setBasedir( sourceDir );

    ds.setIncludes(sourceIncludes.toArray(new String[sourceIncludes.size()]));
    ds.setExcludes(sourceExcludes.toArray(new String[sourceExcludes.size()]));

    ds.addDefaultExcludes();

    try {
        ds.scan();
    } catch (IllegalStateException e) {
        // the source directory (java/) does not exist
        return new String[0];
    }

    return ds.getIncludedFiles();
}
 

import org.codehaus.plexus.util.DirectoryScanner; //导入方法依赖的package包/类
/**
 * Collects files using globs if any
 * @param globs globs
 * @return list of files matching given globs
 */
private Collection<String> collectFilesUsingGlobs(List<String> globs) {
    if (globs == null || globs.isEmpty()) {
        return Collections.emptyList();
    }
    LOGGER.info("Collecting files using globs");
    final DirectoryScanner directoryScanner = new DirectoryScanner();
    String globsArray[] = new String[globs.size()];
    globs.toArray(globsArray);
    directoryScanner.setIncludes(globsArray);
    directoryScanner.setExcludes(new String[] {".gradle-srclib/**", ".m2-srclib/**"});
    directoryScanner.setBasedir(PathUtil.CWD.toString());
    directoryScanner.scan();
    Collection<String> files = new LinkedList<>();
    for (String fileName : directoryScanner.getIncludedFiles()) {
        files.add(PathUtil.concat(PathUtil.CWD, fileName).toString());
    }
    return files;
}
 

import org.codehaus.plexus.util.DirectoryScanner; //导入方法依赖的package包/类
private boolean upToDate( File targetPath, File testRunnerFile )
{
    if ( ! testRunnerFile.exists() )
    {
        return false;
    }

    final DateFormat dateFormat = SimpleDateFormat.getDateTimeInstance();
    final DirectoryScanner directoryScanner = new DirectoryScanner();
    directoryScanner.setIncludes( new String[]{ cxxTest.getTestHeaderPattern() } );
    directoryScanner.setBasedir( targetPath );
    directoryScanner.scan();

    getLog().debug( "Test runner last modified " + dateFormat.format( testRunnerFile.lastModified() ) );
    for ( String fileName : directoryScanner.getIncludedFiles() )
    {
        final File file = new File( targetPath, fileName );
        getLog().debug( fileName + " last modified " + dateFormat.format( file.lastModified() ) );
        if ( FileUtils.isFileNewer( file, testRunnerFile ) )
        {
            return false;
        }
    }
    return true;
}
 

import org.codehaus.plexus.util.DirectoryScanner; //导入方法依赖的package包/类
/**
 * Gets the list of packages from {@literal src/main/java}. This method scans for ".class" files in {@literal
 * target/classes}.
 *
 * @return the list of packages, empty if none.
 */
public Set<String> getPackagesFromMainSources() {
    Set<String> packages = new LinkedHashSet<>();
    File classes = getClassesDirectory();
    if (classes.isDirectory()) {
        DirectoryScanner scanner = new DirectoryScanner();
        scanner.setBasedir(classes);
        scanner.setIncludes(new String[]{"**/*.class"});
        scanner.addDefaultExcludes();
        scanner.scan();

        for (int i = 0; i < scanner.getIncludedFiles().length; i++) {
            packages.add(Packages.getPackageName(scanner.getIncludedFiles()[i]));
        }
    }

    return packages;
}