Examples with DirectoryScanner org.codehaus.plexus.util.DirectoryScanner used on opensource projects

Example 1 with DirectoryScanner

use of org.codehaus.plexus.util.DirectoryScanner in project sass-maven-plugin by Jasig.

the class Resource method getDirectoriesAndDestinations.

public Map<String, String> getDirectoriesAndDestinations() {
    final File sourceDirectory = new File(source.getDirectory());
    // Scan for directories
    final DirectoryScanner scanner = new DirectoryScanner();
    scanner.setBasedir(sourceDirectory);
    scanner.setIncludes(source.getIncludes().toArray(new String[source.getIncludes().size()]));
    scanner.setExcludes(source.getExcludes().toArray(new String[source.getExcludes().size()]));
    // Add default excludes to the list of excludes (see http://plexus.codehaus.org/plexus-utils/apidocs/org/codehaus/plexus/util/AbstractScanner.html#DEFAULTEXCLUDES
    // or http://plexus.codehaus.org/plexus-utils/apidocs/org/codehaus/plexus/util/AbstractScanner.html#addDefaultExcludes() )
    scanner.addDefaultExcludes();
    scanner.scan();
    final Map<String, String> result = new LinkedHashMap<String, String>();
    result.put(FilenameUtils.separatorsToUnix(sourceDirectory.toString()), FilenameUtils.separatorsToUnix(destination.toString()));
    for (String included : scanner.getIncludedDirectories()) {
        if (!included.isEmpty()) {
            final String subdir = StringUtils.difference(sourceDirectory.toString(), included);
            final File sourceDir = new File(sourceDirectory, included);
            File destDir = new File(this.destination, subdir);
            if (this.relativeOutputDirectory != null && !this.relativeOutputDirectory.isEmpty()) {
                destDir = new File(destDir, this.relativeOutputDirectory);
            }
            result.put(FilenameUtils.separatorsToUnix(sourceDir.toString()), FilenameUtils.separatorsToUnix(destDir.toString()));
        }
    }
    return result;
}

Example 2 with DirectoryScanner

use of org.codehaus.plexus.util.DirectoryScanner in project maven-plugins by apache.

the class AbstractJavadocMojo method fixFrameInjectionBug.

/**
     * Patches the given Javadoc output directory to work around CVE-2013-1571
     * (see http://www.kb.cert.org/vuls/id/225657).
     *
     * @param javadocOutputDirectory directory to scan for vulnerabilities
     * @param outputEncoding         encoding used by the javadoc tool (-docencoding parameter).
     *                               If {@code null}, the platform's default encoding is used (like javadoc does).
     * @return the number of patched files
     */
private int fixFrameInjectionBug(File javadocOutputDirectory, String outputEncoding) throws IOException {
    final String fixData;
    InputStream in = null;
    try {
        in = this.getClass().getResourceAsStream("frame-injection-fix.txt");
        if (in == null) {
            throw new FileNotFoundException("Missing resource 'frame-injection-fix.txt' in classpath.");
        }
        fixData = StringUtils.unifyLineSeparators(IOUtil.toString(in, "US-ASCII")).trim();
        in.close();
        in = null;
    } finally {
        IOUtil.close(in);
    }
    final DirectoryScanner ds = new DirectoryScanner();
    ds.setBasedir(javadocOutputDirectory);
    ds.setCaseSensitive(false);
    ds.setIncludes(new String[] { "**/index.html", "**/index.htm", "**/toc.html", "**/toc.htm" });
    ds.addDefaultExcludes();
    ds.scan();
    int patched = 0;
    for (String f : ds.getIncludedFiles()) {
        final File file = new File(javadocOutputDirectory, f);
        // we load the whole file as one String (toc/index files are
        // generally small, because they only contain frameset declaration):
        final String fileContents = FileUtils.fileRead(file, outputEncoding);
        // check if file may be vulnerable because it was not patched with "validURL(url)":
        if (!StringUtils.contains(fileContents, "function validURL(url) {")) {
            // we need to patch the file!
            final String patchedFileContents = StringUtils.replaceOnce(fileContents, "function loadFrames() {", fixData);
            if (!patchedFileContents.equals(fileContents)) {
                FileUtils.fileWrite(file, outputEncoding, patchedFileContents);
                patched++;
            }
        }
    }
    return patched;
}

Example 3 with DirectoryScanner

use of org.codehaus.plexus.util.DirectoryScanner in project felix by apache.

the class BundlePlugin method addLocalPackages.

private static void addLocalPackages(File outputDirectory, Analyzer analyzer) throws IOException {
    Packages packages = new Packages();
    if (outputDirectory != null && outputDirectory.isDirectory()) {
        // scan classes directory for potential packages
        DirectoryScanner scanner = new DirectoryScanner();
        scanner.setBasedir(outputDirectory);
        scanner.setIncludes(new String[] { "**/*.class" });
        scanner.addDefaultExcludes();
        scanner.scan();
        String[] paths = scanner.getIncludedFiles();
        for (int i = 0; i < paths.length; i++) {
            packages.put(analyzer.getPackageRef(getPackageName(paths[i])));
        }
    }
    Packages exportedPkgs = new Packages();
    Packages privatePkgs = new Packages();
    boolean noprivatePackages = "!*".equals(analyzer.getProperty(Analyzer.PRIVATE_PACKAGE));
    for (PackageRef pkg : packages.keySet()) {
        // mark all source packages as private by default (can be overridden by export list)
        privatePkgs.put(pkg);
        // we can't export the default package (".") and we shouldn't export internal packages
        String fqn = pkg.getFQN();
        if (noprivatePackages || !(".".equals(fqn) || fqn.contains(".internal") || fqn.contains(".impl"))) {
            exportedPkgs.put(pkg);
        }
    }
    Properties properties = analyzer.getProperties();
    String exported = properties.getProperty(Analyzer.EXPORT_PACKAGE);
    if (exported == null) {
        if (!properties.containsKey(Analyzer.EXPORT_CONTENTS)) {
            // no -exportcontents overriding the exports, so use our computed list
            for (Attrs attrs : exportedPkgs.values()) {
                attrs.put(Constants.SPLIT_PACKAGE_DIRECTIVE, "merge-first");
            }
            properties.setProperty(Analyzer.EXPORT_PACKAGE, Processor.printClauses(exportedPkgs));
        } else {
            // leave Export-Package empty (but non-null) as we have -exportcontents
            properties.setProperty(Analyzer.EXPORT_PACKAGE, "");
        }
    } else if (exported.indexOf(LOCAL_PACKAGES) >= 0) {
        String newExported = StringUtils.replace(exported, LOCAL_PACKAGES, Processor.printClauses(exportedPkgs));
        properties.setProperty(Analyzer.EXPORT_PACKAGE, newExported);
    }
    String internal = properties.getProperty(Analyzer.PRIVATE_PACKAGE);
    if (internal == null) {
        if (!privatePkgs.isEmpty()) {
            for (Attrs attrs : privatePkgs.values()) {
                attrs.put(Constants.SPLIT_PACKAGE_DIRECTIVE, "merge-first");
            }
            properties.setProperty(Analyzer.PRIVATE_PACKAGE, Processor.printClauses(privatePkgs));
        } else {
            // if there are really no private packages then use "!*" as this will keep the Bnd Tool happy
            properties.setProperty(Analyzer.PRIVATE_PACKAGE, "!*");
        }
    } else if (internal.indexOf(LOCAL_PACKAGES) >= 0) {
        String newInternal = StringUtils.replace(internal, LOCAL_PACKAGES, Processor.printClauses(privatePkgs));
        properties.setProperty(Analyzer.PRIVATE_PACKAGE, newInternal);
    }
}

Example 4 with DirectoryScanner

use of org.codehaus.plexus.util.DirectoryScanner in project felix by apache.

the class MavenProjectScanner method getSources.

/**
 * Return all sources.
 */
public Collection<Source> getSources() {
    if (scanClasses) {
        final ArrayList<Source> files = new ArrayList<Source>();
        final DirectoryScanner scanner = new DirectoryScanner();
        scanner.setBasedir(this.project.getBuild().getOutputDirectory());
        if (this.includeString != null) {
            scanner.setIncludes(this.includeString.split(","));
        } else {
            scanner.setIncludes(new String[] { "**/*.class" });
        }
        if (this.excludeString != null) {
            scanner.setExcludes(this.excludeString.split(","));
        }
        scanner.addDefaultExcludes();
        scanner.scan();
        for (final String fileName : scanner.getIncludedFiles()) {
            files.add(new Source() {

                public File getFile() {
                    return new File(project.getBuild().getOutputDirectory(), fileName);
                }

                public String getClassName() {
                    // remove ".class"
                    String name = fileName.substring(0, fileName.length() - 6);
                    return name.replace(File.separatorChar, '/').replace('/', '.');
                }
            });
        }
        return files;
    }
    return getSourcesForScanKind(ScanKind.ADDED_OR_UPDATED);
}

Example 5 with DirectoryScanner

use of org.codehaus.plexus.util.DirectoryScanner in project intellij-plugins by JetBrains.

the class LocalPackageCollector method addLocalPackages.

private static void addLocalPackages(File outputDirectory, Analyzer analyzer) {
    Collection<String> packages = new LinkedHashSet<String>();
    if (outputDirectory != null && outputDirectory.isDirectory()) {
        // scan classes directory for potential packages
        DirectoryScanner scanner = new DirectoryScanner();
        scanner.setBasedir(outputDirectory);
        scanner.setIncludes(new String[] { "**/*.class" });
        scanner.addDefaultExcludes();
        scanner.scan();
        String[] paths = scanner.getIncludedFiles();
        for (String path : paths) {
            packages.add(getPackageName(path));
        }
    }
    StringBuilder exportedPackages = new StringBuilder();
    StringBuilder privatePackages = new StringBuilder();
    boolean noPrivatePackages = "!*".equals(analyzer.getProperty(Constants.PRIVATE_PACKAGE));
    for (Object aPackage : packages) {
        String pkg = (String) aPackage;
        // mark all source packages as private by default (can be overridden by export list)
        if (privatePackages.length() > 0) {
            privatePackages.append(';');
        }
        privatePackages.append(pkg);
        // we can't export the default package (".") and we shouldn't export internal packages
        if (noPrivatePackages || !(".".equals(pkg) || pkg.contains(".internal") || pkg.contains(".impl"))) {
            if (exportedPackages.length() > 0) {
                exportedPackages.append(';');
            }
            exportedPackages.append(pkg);
        }
    }
    if (analyzer.getProperty(Constants.EXPORT_PACKAGE) == null) {
        if (analyzer.getProperty(Constants.EXPORT_CONTENTS) == null) {
            // no -exportcontents overriding the exports, so use our computed list
            analyzer.setProperty(Constants.EXPORT_PACKAGE, exportedPackages + ";-split-package:=merge-first");
        } else {
            // leave Export-Package empty (but non-null) as we have -exportcontents
            analyzer.setProperty(Constants.EXPORT_PACKAGE, "");
        }
    } else {
        String exported = analyzer.getProperty(Constants.EXPORT_PACKAGE);
        if (exported.contains(LOCAL_PACKAGES)) {
            String newExported = StringUtil.replace(exported, LOCAL_PACKAGES, exportedPackages.toString());
            analyzer.setProperty(Constants.EXPORT_PACKAGE, newExported);
        }
    }
    String internal = analyzer.getProperty(Constants.PRIVATE_PACKAGE);
    if (internal == null) {
        if (privatePackages.length() > 0) {
            analyzer.setProperty(Constants.PRIVATE_PACKAGE, privatePackages + ";-split-package:=merge-first");
        } else {
            // if there are really no private packages then use "!*" as this will keep the Bnd Tool happy
            analyzer.setProperty(Constants.PRIVATE_PACKAGE, "!*");
        }
    } else if (internal.contains(LOCAL_PACKAGES)) {
        String newInternal = StringUtil.replace(internal, LOCAL_PACKAGES, privatePackages.toString());
        analyzer.setProperty(Constants.PRIVATE_PACKAGE, newInternal);
    }
}