org.apache.tools.ant.types.FileSet Java Examples

/**
 * ants execute method.
 */
@Override
public void execute() {
	try {
		for (final FileSet fileset : filesets) {
			final DirectoryScanner ds = fileset.getDirectoryScanner(getProject());
			final String[] includedFiles = ds.getIncludedFiles();
			for (final String filename : includedFiles) {
				String signature = sign(ds.getBasedir().getAbsolutePath()
						+ File.separator + filename);
				System.out.println("file-signature." + filename + "=" + signature);
			}
		}
	} catch (final Exception e) {
		throw new BuildException(e);
	}
}
 

@Before
public void setUp() {
    TestHelper.cleanCache();
    project = TestHelper.newProject();
    project.setProperty("ivy.cache.dir", TestHelper.cache.getAbsolutePath());

    AntWorkspaceResolver antWorkspaceResolver = new AntWorkspaceResolver();
    antWorkspaceResolver.setName("test-workspace");
    wa = antWorkspaceResolver.createArtifact();
    FileSet fileset = new FileSet();
    fileset.setProject(project);
    fileset.setDir(new File("test/workspace"));
    fileset.setIncludes("*/ivy.xml");
    antWorkspaceResolver.addConfigured(fileset);
    antWorkspaceResolver.setProject(project);

    configure = new IvyConfigure();
    configure.setProject(project);
    configure.setFile(new File("test/workspace/ivysettings.xml"));
    configure.addConfiguredWorkspaceResolver(antWorkspaceResolver);
    configure.execute();
}
 

/**
 * ants execute method.
 */
@Override
public void execute() {
	try {
		for (final FileSet fileset : filesets) {
			final DirectoryScanner ds = fileset.getDirectoryScanner(getProject());
			final String[] includedFiles = ds.getIncludedFiles();
			for (final String filename : includedFiles) {
				System.out.println(ds.getBasedir().getAbsolutePath() + File.separator + filename);
				convert(ds.getBasedir().getAbsolutePath() + File.separator + filename);
			}
		}
	} catch (final Exception e) {
		throw new BuildException(e);
	}
}
 

/**
 * Returns the list of input files ({@link java.io.File} objects) to process.
 * Note that this does not check that the file is a valid and useful XML file.
 * 
 * @return The input files
 */
private List getInputFiles()
{
	ArrayList result = new ArrayList();

    for (Iterator it = _fileSets.iterator(); it.hasNext();)
    {
        FileSet          fileSet    = (FileSet)it.next();
        File             fileSetDir = fileSet.getDir(getProject());
        DirectoryScanner scanner    = fileSet.getDirectoryScanner(getProject());
        String[]         files      = scanner.getIncludedFiles();

        for (int idx = 0; (files != null) && (idx < files.length); idx++)
        {
        	File file = new File(fileSetDir, files[idx]);

            if (file.isFile() && file.canRead())
            {
            	result.add(file);
            }
        }
    }
    return result;
}
 

/**
 * Invoke the Hadoop record compiler on each record definition file
 */
@Override
public void execute() throws BuildException {
  if (src == null && filesets.size()==0) {
    throw new BuildException("There must be a file attribute or a fileset child element");
  }
  if (src != null) {
    doCompile(src);
  }
  Project myProject = getProject();
  for (int i = 0; i < filesets.size(); i++) {
    FileSet fs = filesets.get(i);
    DirectoryScanner ds = fs.getDirectoryScanner(myProject);
    File dir = fs.getDir(myProject);
    String[] srcs = ds.getIncludedFiles();
    for (int j = 0; j < srcs.length; j++) {
      doCompile(new File(dir, srcs[j]));
    }
  }
}
 

@Test
public void testExecuteMultipleFiles() throws IOException {
    UploadFileSetToS3Task task = new UploadFileSetToS3Task();
    task.setProject(new Project());
    FileSet fileset = new FileSet();
    fileset.setDir(testFile1.getParentFile());
    fileset.setIncludes("*.txt");
    task.addFileset(fileset);
    task.setBucketName(BUCKET_NAME);
    task.setKeyPrefix(KEY_PREFIX);
    task.execute();
    resFile1 = File.createTempFile(RES_FILE_1, TESTFILE_SUFFIX);
    resFile2 = File.createTempFile(RES_FILE_2, TESTFILE_SUFFIX);
    resFile3 = File.createTempFile(RES_FILE_3, TESTFILE_SUFFIX);
    client.getObject(new GetObjectRequest(BUCKET_NAME, KEY_PREFIX
            + fileName1), resFile1);
    client.getObject(new GetObjectRequest(BUCKET_NAME, KEY_PREFIX
            + fileName2), resFile2);
    client.getObject(new GetObjectRequest(BUCKET_NAME, KEY_PREFIX
            + fileName3), resFile3);
    assertTrue(FileUtils.contentEquals(testFile1, resFile1));
    assertTrue(FileUtils.contentEquals(testFile1, resFile1));
    assertTrue(FileUtils.contentEquals(testFile1, resFile1));
}
 

@Test
public void testReverse() {
    FileSet fs = new FileSet();
    fs.setDir(new File("test/buildlist"));
    fs.setIncludes("**/build.xml");
    fs.setExcludes("E2/build.xml,F/build.xml,G/build.xml");

    buildlist.addFileset(fs);
    buildlist.setReverse(true);
    buildlist.setOnMissingDescriptor("skip");

    String[] files = getFiles(buildlist);

    assertEquals(5, files.length);

    assertListOfFiles("test/buildlist/", new String[] {"E", "D", "A", "C", "B"}, files);
}
 

/**
 * Returns the list of input files ({@link java.io.File} objects) to process.
 * Note that this does not check that the file is a valid and useful XML file.
 * 
 * @return The input files
 */
private List getInputFiles()
{
	ArrayList result = new ArrayList();

    for (Iterator it = _fileSets.iterator(); it.hasNext();)
    {
        FileSet          fileSet    = (FileSet)it.next();
        File             fileSetDir = fileSet.getDir(getProject());
        DirectoryScanner scanner    = fileSet.getDirectoryScanner(getProject());
        String[]         files      = scanner.getIncludedFiles();

        for (int idx = 0; (files != null) && (idx < files.length); idx++)
        {
        	File file = new File(fileSetDir, files[idx]);

            if (file.isFile() && file.canRead())
            {
            	result.add(file);
            }
        }
    }
    return result;
}
 

@Override
public void execute() throws BuildException {
    BasicStyleCheckerEngine engine = new BasicStyleCheckerEngine();
    
    try {
        for (FileSet fileset: filesets) {
            final DirectoryScanner scanner =
                    fileset.getDirectoryScanner(getProject());
            
            for (String filename: scanner.getIncludedFiles()) {
                final File file =
                        new File(fileset.getDir(getProject()), filename);
                
                System.out.println(file.getCanonicalPath());
                engine.check(file);
            }
        }
    } catch (IOException e) {
        throw new BuildException(e);
    }
}
 

@Test
public void testWithTwoRoots() {
    FileSet fs = new FileSet();
    fs.setDir(new File("test/buildlist"));
    fs.setIncludes("**/build.xml");
    fs.setExcludes("E2/**");

    buildlist.addFileset(fs);
    buildlist.setRoot("C,E");
    buildlist.setOnMissingDescriptor("skip");

    String[] files = getFiles(buildlist);

    assertEquals(3, files.length); // A and D should be filtered out

    assertListOfFiles("test/buildlist/", new String[] {"B", "C", "E"}, files);
}
 

@Test
public void testWithModuleWithSameNameAndDifferentOrg() {
    FileSet fs = new FileSet();
    fs.setDir(new File("test/buildlist"));
    fs.setIncludes("**/build.xml");
    fs.setExcludes("F/build.xml,G/build.xml");

    buildlist.addFileset(fs);
    buildlist.setOnMissingDescriptor("skip");

    String[] files = getFiles(buildlist);

    assertEquals(6, files.length);

    assertListOfFiles("test/buildlist/", new String[] {"B", "C", "A", "D"}, files);

    // the order of E and E2 is undefined
    List<URI> other = new ArrayList<>();
    other.add(new File(files[4]).getAbsoluteFile().toURI());
    other.add(new File(files[5]).getAbsoluteFile().toURI());
    Collections.sort(other);

    assertEquals(new File("test/buildlist/E/build.xml").getAbsoluteFile().toURI(), other.get(0));
    assertEquals(new File("test/buildlist/E2/build.xml").getAbsoluteFile().toURI(),
        other.get(1));
}
 

@Test
public void testNoParents() {
    FileSet fs = new FileSet();
    fs.setDir(new File("test/buildlists/testNoParents"));
    fs.setIncludes("**/build.xml");

    buildlist.addFileset(fs);
    buildlist.setOnMissingDescriptor("skip");
    buildlist.setHaltonerror(false);

    String[] files = getFiles(buildlist);

    assertEquals(5, files.length);

    assertListOfFiles("test/buildlists/testNoParents/", new String[] {"bootstrap-parent",
            "ireland", "germany", "master-parent", "croatia"}, files);
}
 

/**
 * Returns an array with the file names of the specified file pattern that have been found in the workspace.
 *
 * @param workspace
 *         root directory of the workspace
 *
 * @return the file names of all found files
 */
public String[] find(final File workspace) {
    try {
        FileSet fileSet = new FileSet();
        Project antProject = new Project();
        fileSet.setProject(antProject);
        fileSet.setDir(workspace);
        fileSet.setIncludes(includesPattern);
        TypeSelector selector = new TypeSelector();
        FileType fileType = new FileType();
        fileType.setValue(FileType.FILE);
        selector.setType(fileType);
        fileSet.addType(selector);
        if (StringUtils.isNotBlank(excludesPattern)) {
            fileSet.setExcludes(excludesPattern);
        }
        fileSet.setFollowSymlinks(followSymlinks);

        return fileSet.getDirectoryScanner(antProject).getIncludedFiles();
    }
    catch (BuildException ignored) {
        return new String[0]; // as fallback do not return any file
    }
}
 

private boolean setNextObject() {
    while (true) {
        while (ds == null) {
            if (!fileSetIterator.hasNext()) {
                return false;
            }
            FileSet fs = fileSetIterator.next();
            ds = fs.getDirectoryScanner(project);
            ds.scan();
            if (iterateDirectories) {
                files = ds.getIncludedDirectories();
            } else {
                files = ds.getIncludedFiles();
            }
            if (files.length > 0) {
                fileIndex = -1;
                break;
            } else {
                ds = null;
            }
        }

        if (ds != null && files != null) {
            if (++fileIndex < files.length) {
                nextFile = new File(ds.getBasedir(), files[fileIndex]);
                nextObjectSet = true;
                return true;
            } else {
                ds = null;
            }
        }
    }
}
 

private void generateVersionXMLFiles() throws IOException {
    FileSet fs = new FileSet();
    fs.setIncludes("**/*.jar");
    for (File directory : jarDirectories) {
        fs.setDir(directory);
        DirectoryScanner scan = fs.getDirectoryScanner(getProject());
        StringWriter writeVersionXML = new StringWriter();
        writeVersionXML.append("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n");
        writeVersionXML.append("<jnlp-versions>\n");
        for (String jarName : scan.getIncludedFiles()) {
            File jar = new File(scan.getBasedir(), jarName);
            JarFile jarFile = new JarFile(jar);
            String version = getJarVersion(jarFile);
            if (version != null) {
                writeVersionXML.append("    <resource>\n        <pattern>\n            <name>");
                writeVersionXML.append(jar.getName());
                writeVersionXML.append("</name>\n            <version-id>");
                writeVersionXML.append(version);
                writeVersionXML.append("</version-id>\n        </pattern>\n        <file>");
                writeVersionXML.append(jar.getName());
                writeVersionXML.append("</file>\n    </resource>\n");
            } else {
                writeVersionXML.append("    <!-- No version found for ");
                writeVersionXML.append(jar.getName());
                writeVersionXML.append(" -->\n");
            }
        }
        writeVersionXML.append("</jnlp-versions>\n");
        writeVersionXML.close();

        File versionXML = new File(directory, "version.xml");
        FileWriter w = new FileWriter(versionXML);
        w.write(writeVersionXML.toString());
        w.close();
    }
}
 

private void downloadBinaries(boolean clean) {
    DownloadBinaries task = new DownloadBinaries();
    task.setProject(new Project());
    task.setCache(cache);
    task.setClean(clean);
    task.setServer(server.toURI().toString());
    FileSet manifest = new FileSet();
    manifest.setFile(list);
    task.addManifest(manifest);
    task.execute();
}
 

/**
 * Perform the conversion
 *
 * @throws BuildException if an error occurs during execution of
 *    this task.
 */
@Override
public void execute()
    throws BuildException
{
    int count = 0;

    // Step through each file and convert.
    Iterator<FileSet> iter = filesets.iterator();
    while( iter.hasNext() ) {
        FileSet fs = iter.next();
        DirectoryScanner ds = fs.getDirectoryScanner(getProject());
        File basedir = ds.getBasedir();
        String[] files = ds.getIncludedFiles();
        for( int i = 0; i < files.length; i++ ) {
            File from = new File( basedir, files[i] );
            File to = new File( todir, files[i] + ".html" );
            if( !to.exists() ||
                (from.lastModified() > to.lastModified()) )
            {
                log( "Converting file '" + from.getAbsolutePath() +
                    "' to '" + to.getAbsolutePath(), Project.MSG_VERBOSE );
                try {
                    convert( from, to );
                }
                catch( IOException e ) {
                    throw new BuildException( "Could not convert '" +
                        from.getAbsolutePath() + "' to '" +
                        to.getAbsolutePath() + "'", e );
                }
                count++;
            }
        }
        if( count > 0 ) {
            log( "Converted " + count + " file" + (count > 1 ? "s" : "") +
                " to " + todir.getAbsolutePath() );
        }
    }
}
 

private FileSet createFileSetForJarFile(File jarFile, Project prj)
{
    FileSet fileSet = new FileSet();
    fileSet.setProject(prj);
    fileSet.setFile(jarFile);
    return fileSet;
}
 

/** Nested <schema> element. */
public void addConfiguredSchema( FileSet fs ) {
    for (InputSource value : toInputSources(fs))
        options.addGrammar(value);
    
    addIndividualFilesTo( fs, dependsSet );
}
 

/** Sets a directory as base for class files. The implicit pattern '**/*.class' is used to only scan class files. */
public void setDir(File dir) {
  final FileSet fs = new FileSet();
  fs.setProject(getProject());
  fs.setDir(dir);
  // needed if somebody sets restrictClassFilename=false:
  fs.setIncludes("**/*.class");
  classFiles.add(fs);
}
 

@Override
public void execute() throws BuildException {
    Set<String> filePaths = new HashSet<>();
    File tmpFile = null;
    for (FileSet fs : filesets) {
        if (fs != null) {
            DirectoryScanner scan = fs.getDirectoryScanner(getProject());
            for (String f : scan.getIncludedFiles()) {
                filePaths.add(fs.getDir().getAbsolutePath() + File.separatorChar + f.replace(File.separatorChar, '/'));
            }
        }
    }
    try {
        for (String filePathIter : filePaths) {
            File jarFile = new File(filePathIter);
            if (isSigned(jarFile) == null) {
                tmpFile = extendLibraryManifest(getProject(), jarFile, jarFile, codebase, permissions, appName);
            }
            if (tmpFile != null) {
                sign(tmpFile, jarFile);
                deleteTmpFile(tmpFile);
            } else {
                sign(jarFile, jarFile);
            }

        }
    } catch (IOException | ManifestException ex) {
        getProject().log(
                "Failed to extend libraries manifests: " + ex.getMessage(), //NOI18N
                Project.MSG_WARN);
    }
}
 

public @Override void execute() throws BuildException {
    try (FileOutputStream fos = new FileOutputStream(new File(getProject().getBaseDir(), exclusionFile));
            OutputStreamWriter osw = new OutputStreamWriter(fos);
            BufferedWriter bw = new BufferedWriter(osw)) {
        Path nballPath = nball.toPath();
        List<File> licenseinfofiles = Files.walk(nballPath)
                .filter(p -> p.endsWith("licenseinfo.xml"))
                .map(p -> p.toFile())
                .collect(Collectors.toList());

        FileSet licenseinfoFileset = new FileSet();
        licenseinfoFileset.setProject(getProject());
        licenseinfoFileset.setDir(nball.getAbsoluteFile());

        for(File licenseInfoFile: licenseinfofiles) {
            Licenseinfo li = Licenseinfo.parse(licenseInfoFile);
            for(Fileset fs: li.getFilesets()) {
                for(File f: fs.getFiles()) {
                    Path relativePath = nball.toPath().relativize(f.toPath());
                    licenseinfoFileset.appendIncludes(new String[]{relativePath.toString()});
                    bw.write(relativePath.toString());
                    bw.newLine();
                }
            }
        }
        
        getProject().addReference(this.licenseinfoFileset, licenseinfoFileset);
    } catch (IOException ex) {
        throw new BuildException(ex);
    }
}
 

private static File[] scanFileSet(FileSet fs) {
    Project prj = fs.getProject();
    DirectoryScanner scanner = fs.getDirectoryScanner(prj);
    scanner.scan();
    File basedir = scanner.getBasedir();
    String[] fileNames = scanner.getIncludedFiles();
    File[] ret = new File[fileNames.length];
    for (int i = 0; i < fileNames.length; i++) {
        String fileName = fileNames[i];
        ret[i] = new File(basedir, fileName);
    }
    return ret;
}
 

@Override
protected void configureFindbugsEngine() {
    addArg("-withMessages");
    addArg("-output");
    addArg(to);
    for (FileSet s : fileSets) {
        File fromDir = s.getDir(getProject());
        for (String file : s.getDirectoryScanner(getProject()).getIncludedFiles()) {
            addArg(new File(fromDir, file).toString());
        }
    }

}
 

/**
 * Add a file set with classes that shall be exported.
 *
 * @param set The file set with exports to add.
 */
public void addConfiguredExports(FileSet set) {
  final Restrict restrict = new Restrict();
  restrict.add(set);
  restrict.add(analyzeRestriction);
  exportsResourceCollections.add(restrict);
}
 

private void scanModules(FileSet fs, boolean isEnabled, boolean isAutoload, boolean isEager, boolean isHidden, List<String> names) throws BuildException {
    FileScanner scan = fs.getDirectoryScanner(getProject());
    File dir = scan.getBasedir();
    for (String kid : scan.getIncludedFiles()) {
        File module = new File(dir, kid);
        scanOneModule(module, kid, isEnabled, isAutoload, isEager, isHidden, names);
    }
}
 

private void addImplicitFileset()
{
  if (baseDir != null) {
    final FileSet fileset = (FileSet) getImplicitFileSet().clone();
    fileset.setDir(baseDir);
    srcFilesets.add(fileset);
  }
}
 

@Test
public void testEmptyConf() {
    project.setProperty("ivy.dep.file", "test/java/org/apache/ivy/ant/ivy-108.xml");
    fileset.setSetid("emptyconf-setid");
    fileset.setConf("empty");
    fileset.execute();
    Object ref = project.getReference("emptyconf-setid");
    assertNotNull(ref);
    assertTrue(ref instanceof FileSet);
    FileSet fs = (FileSet) ref;
    DirectoryScanner directoryScanner = fs.getDirectoryScanner(project);
    directoryScanner.scan();
    assertEquals(0, directoryScanner.getIncludedFiles().length);
}
 

public void addConfiguredFileSet(FileSet fs) {
  DirectoryScanner scanner = fs.getDirectoryScanner(getProject());
  File baseDir = scanner.getBasedir();
  scanner.scan();
  String[] includedFiles = scanner.getIncludedFiles();
  Arrays.sort(includedFiles);
  for (String localPath : includedFiles) {
    files.add(new File(baseDir, localPath));
  }
}
 

/** Add a set of module JARs that should be hidden.
 */
public void addHidden(FileSet fs) {
    hidden.add(fs);
}