org.codehaus.plexus.util.Scanner Java Examples

protected Set<String> getIncludedSources()
        throws MojoExecutionException {
    Set<String> result = new HashSet<String>();
    if (getJavaSources() == null) {
        result = AjcHelper.getBuildFilesForSourceDirs(getSourceDirectories(), this.includes, this.excludes);
    } else {
        for (int scannerIndex = 0; scannerIndex < getJavaSources().length; scannerIndex++) {
            Scanner scanner = getJavaSources()[scannerIndex];
            if (scanner.getBasedir() == null) {
                getLog().info("Source without basedir, skipping it.");
            } else {
                scanner.scan();
                for (int fileIndex = 0; fileIndex < scanner.getIncludedFiles().length; fileIndex++) {
                    result.add(FileUtils.resolveFile(scanner.getBasedir(),
                            scanner.getIncludedFiles()[fileIndex]).getAbsolutePath());
                }
            }
        }
    }
    return result;
}
 

static boolean shouldExecute(BuildContext buildContext, List<File> triggerfiles, File srcdir) {

    // If there is no buildContext, or this is not an incremental build, always execute.
    if (buildContext == null || !buildContext.isIncremental()) {
      return true;
    }

    if (triggerfiles != null) {
      for (File triggerfile : triggerfiles) {
        if (buildContext.hasDelta(triggerfile)) {
          return true;
        }
      }
    }

    if (srcdir == null) {
      return true;
    }

    // Check for changes in the srcdir
    Scanner scanner = buildContext.newScanner(srcdir);
    scanner.scan();
    String[] includedFiles = scanner.getIncludedFiles();
    return (includedFiles != null && includedFiles.length > 0);
  }
 

/**
 * Initializes the Scanner with the default values.
 * <br>
 * By default:
 * <ul>
 *     <li>includes adds extension .adoc, .ad, .asc and .asciidoc
 *     <li>excludes adds filters to avoid hidden files and directoris beginning with undersore
 * </ul>
 *
 * NOTE: Patterns both in inclusions and exclusions are automatically excluded.
 */
private void setupScanner(Scanner scanner, Resource resource) {

    if (resource.getIncludes() == null || resource.getIncludes().isEmpty()) {
        scanner.setIncludes(DEFAULT_FILE_EXTENSIONS);
    } else {
        scanner.setIncludes(resource.getIncludes().toArray(new String[] {}));
    }

    if (resource.getExcludes() == null || resource.getExcludes().isEmpty()) {
        scanner.setExcludes(IGNORED_FOLDERS_AND_FILES);
    } else {
        scanner.setExcludes(mergeAndConvert(resource.getExcludes(), IGNORED_FOLDERS_AND_FILES));
    }
    // adds exclusions like SVN or GIT files
    scanner.addDefaultExcludes();
}
 

/**
 * Scan for project resources and produce a comma separated list of include resources.
 *
 * @return list of resources
 */
private Map<String, List<String>> scanResources() {
    getLog().debug("Scanning project resources");
    Map<String, List<String>> allResources = new HashMap<>();
    for (Resource resource : project.getResources()) {
        List<String> resources = new ArrayList<>();
        allResources.put(resource.getDirectory(), resources);
        File resourcesDir = new File(resource.getDirectory());
        Scanner scanner = buildContext.newScanner(resourcesDir);
        String[] includes = null;
        if (resource.getIncludes() != null
                && !resource.getIncludes().isEmpty()) {
            includes = (String[]) resource.getIncludes()
                    .toArray(new String[resource.getIncludes().size()]);
        }
        scanner.setIncludes(includes);
        String[] excludes = null;
        if (resource.getExcludes() != null
                && !resource.getExcludes().isEmpty()) {
            excludes = (String[]) resource.getExcludes()
                    .toArray(new String[resource.getExcludes().size()]);
        }
        scanner.setExcludes(excludes);
        scanner.scan();
        for (String included : scanner.getIncludedFiles()) {
            getLog().debug("Found resource: " + included);
            resources.add(included);
        }
    }
    return allResources;
}
 

/**
 * Scans given directory for files satisfying given inclusion/exclusion
 * patterns.
 * 
 * @param buildContext
 *            Build context provided by the environment, used to scan for files.
 * @param directory
 *            Directory to scan.
 * @param includes
 *            inclusion pattern.
 * @param excludes
 *            exclusion pattern.
 * @param defaultExcludes
 *            default exclusion flag.
 * @return Files from the given directory which satisfy given patterns. The
 *         files are {@link File#getCanonicalFile() canonical}.
 * @throws IOException
 *             If an I/O error occurs, which is possible because the
 *             construction of the canonical pathname may require filesystem
 *             queries.
 */
public static List<File> scanDirectoryForFiles(BuildContext buildContext, final File directory,
		final String[] includes, final String[] excludes, boolean defaultExcludes) throws IOException {
	if (!directory.exists()) {
		return Collections.emptyList();
	}
	final Scanner scanner;

	if (buildContext != null) {
		scanner = buildContext.newScanner(directory, true);
	} else {
		final DirectoryScanner directoryScanner = new DirectoryScanner();
		directoryScanner.setBasedir(directory.getAbsoluteFile());
		scanner = directoryScanner;
	}
	scanner.setIncludes(includes);
	scanner.setExcludes(excludes);
	if (defaultExcludes) {
		scanner.addDefaultExcludes();
	}

	scanner.scan();

	final List<File> files = new ArrayList<File>();
	for (final String name : scanner.getIncludedFiles()) {
		files.add(new File(directory, name).getCanonicalFile());
	}

	return files;
}
 

/**
 * Executes the mojo.
 *
 * @throws MojoExecutionException if the plugin execution failed.
 */
@Override
public void execute() throws MojoExecutionException {
    final boolean isIncremental = buildContext.isIncremental();
    declareOutputDirectory();

    int errors = 0;
    for (final String sourceDirectory : compileSourceRoots) {
        final File directory = new File(sourceDirectory);
        if (directory.getName().equals("java")) {
            /*
             * Check if we can skip the resources compilation (Eclipse environment only).
             *
             * Scanner.getIncludedFiles() returns an array of modified files. For now we ignore the array
             * content and unconditionally re-compile all resource files as soon as at least one file has
             * been modified. This is okay for now since changes in resource files are rare and compiling
             * them is very fast.
             */
            if (isIncremental) {
                Scanner scanner = buildContext.newScanner(directory);
                scanner.setIncludes(PROPERTIES_PATTERN);
                scanner.scan();
                final String[] includedFiles = scanner.getIncludedFiles();
                if (includedFiles == null || includedFiles.length == 0) {
                    continue;
                }
            }
            javaDirectoryFile = directory;
            errors += processAllResourceDirectories(directory);
            buildContext.refresh(outputDirectory);
        }
    }
    if (errors != 0) {
        throw new ResourceCompilerException(String.valueOf(errors) + " errors in resources bundles.");
    }
}
 

private Set<File> getSourceFiles()
{
    if (source == null || !source.exists())
    {
        return new TreeSet<>();
    }

    String[] filters = ALL_JAVA_FILES_FILTER;
    if (includes != null && !includes.isEmpty())
    {
        filters = includes.toArray(new String[includes.size()]);
        for (int i = 0; i < filters.length; i++)
        {
            filters[i] = filters[i].replace('.', '/') + JAVA_FILE_FILTER;
        }
    }

    Set<File> files = new HashSet<File>();
    final Scanner scanner = buildContext.newScanner(source);
    scanner.setIncludes(filters);
    scanner.scan();

    String[] includedFiles = scanner.getIncludedFiles();
    if (includedFiles != null)
    {
        for (String includedFile : includedFiles)
        {
            files.add(new File(scanner.getBasedir(), includedFile));
        }
    }
    return files;
}
 

/**
 * Scans a resource directory (and sub-subdirectories) returning all AsciiDoc documents found.
 *
 * @param resource {@link Resource} to scan (the directory property is mandatory)
 * @return List of found documents matching the resource properties
 */
public List<File> scan(Resource resource) {
    Scanner scanner = buildContext.newScanner(new File(resource.getDirectory()), true);
    setupScanner(scanner, resource);
    scanner.scan();
    List<File> files = new ArrayList<File>();
    for (String file : scanner.getIncludedFiles()) {
        files.add(new File(resource.getDirectory(), file));
    }
    return files;
}
 

/**
 * Scan for project resources and produce a comma separated list of include
 * resources.
 * @return String as comma separated list
 */
private String getResources() {
    // scan all resources
    getLog().debug("Building resources string");
    List<String> resources = new ArrayList<>();

    if (addProjectResources) {
        getLog().debug("Scanning project resources");
        for (Resource resource : project.getResources()) {
            File resourcesDir = new File(resource.getDirectory());
            Scanner scanner = buildContext.newScanner(resourcesDir);
            String[] includes = null;
            if (resource.getIncludes() != null
                    && !resource.getIncludes().isEmpty()) {
                includes = (String[]) resource.getIncludes()
                        .toArray(new String[resource.getIncludes().size()]);
            }
            scanner.setIncludes(includes);
            String[] excludes = null;
            if (resource.getExcludes() != null
                    && !resource.getExcludes().isEmpty()) {
                excludes = (String[]) resource.getExcludes()
                        .toArray(new String[resource.getExcludes().size()]);
            }
            scanner.setExcludes(excludes);
            scanner.scan();
            for (String included : scanner.getIncludedFiles()) {
                getLog().debug("Found resource: " + included);
                resources.add(included);
            }
        }
    }

    // add additional resources
    if (includeResources != null) {
        getLog().debug("Adding provided resources: " + includeResources);
        resources.addAll(includeResources);
    }

    // comma separated list
    StringBuilder sb = new StringBuilder();
    Iterator<String> it = resources.iterator();
    while (it.hasNext()) {
        sb.append(it.next());
        if (it.hasNext()) {
            sb.append("|");
        }
    }
    String resourcesStr = sb.toString();
    getLog().debug("Built resources string: " + resourcesStr);
    return resourcesStr;
}
 

@Override
public void execute() throws MojoExecutionException {
	
	List<File> filesToSign = new ArrayList<>();
	
	if ( includeProjectArtifact )
		filesToSign.add(project.getArtifact().getFile());
	
	if ( artifactSets != null ) {
		for ( FileSet artifactSet : artifactSets ) {
  	File base = new File(project.getBasedir(), artifactSet.getDirectory());
  	Scanner scanner = buildContext.newScanner(base);
  	scanner.setIncludes(artifactSet.getIncludes().toArray(new String[0]));
  	scanner.setExcludes(artifactSet.getExcludes().toArray(new String[0]));
  	scanner.scan();
  	for ( String file : scanner.getIncludedFiles() ) {
  		filesToSign.add(new File(base, file));
  	}
		}
	}
	
	if ( filesToSign.isEmpty() ) { 
		getLog().info("No files to sign, skipping");
		return;
	}
	
	for ( File toSign : filesToSign )
		getLog().info("Would sign " + toSign);

    // Set up the TLS client
    System.setProperty("javax.net.ssl.keyStore", keyStore);
    System.setProperty("javax.net.ssl.keyStorePassword", keyStorePassword);
    String oldSslDebug = null;
	if ( sslDebug ) {
	    oldSslDebug = System.setProperty("javax.net.debug","all");
	}
	
    SignedFiles signedFiles = new SignedFiles(filesToSign);
	
    try {
        String signingSetID = makeSigningRequest(signedFiles);
        downloadSignedFiles(signedFiles, signingSetID);
    } catch (SOAPException | IOException e) {
        throw new MojoExecutionException("Signing failed : " + e.getMessage(), e);
    } finally {
        if ( sslDebug ) {
            if ( oldSslDebug != null ) {
                System.setProperty("javax.net.debug", oldSslDebug);
            } else {
                System.clearProperty("javax.net.debug");
            }
        }
    }
}
 

protected Scanner[] getJavaSources()
{
    return testSources;
}
 

protected Scanner[] getJavaSources()
{
    return sources;
}
 

protected abstract Scanner[] getJavaSources();