Factory<PatternSet> createPatternSetFactory() { return fileLookup.getFileResolver().getPatternSetFactory(); } };
public FileTree getAllSource() { final ImmutableList.Builder<FileTree> builder = ImmutableList.builder(); walk(new Action<CopySpecResolver>() { public void execute(CopySpecResolver copySpecResolver) { builder.add(copySpecResolver.getSource()); } }); return fileResolver.compositeFileTree(builder.build()); }
@Override public Directory dir(String path) { File newDir = fileResolver.resolve(path); return new FixedDirectory(newDir, fileResolver.newResolver(newDir)); }
public File file(Object path, PathValidation validation) { return fileResolver.resolve(path, validation); }
@Override public synchronized void registerOutputs(Object files) { if (resolvedPaths != null) { resolvedPaths = null; } this.outputs.add(fileResolver.resolveFiles(files)); }
@Override public TaskInputFilePropertyBuilderInternal call() { return addSpec(resolver.resolveFilesAsTree(dirPath)); } });
public URI uri(Object path) { return fileResolver.resolveUri(path); }
public ReadableResourceInternal gzip(Object path) { return new GzipArchiver(fileOperations.getFileResolver().resolveResource(path)); }
ResolvingDirectory(FileResolver resolver, Object value, Provider<?> valueProvider) { this.resolver = resolver; this.valueProvider = valueProvider; this.valueFactory = resolver.resolveLater(value); }
public String relativePath(Object path) { return fileResolver.resolveAsRelativePath(path); }
@Override public Directory getOrNull() { if (!isPresent()) { return null; } // TODO - factory should cache, and use a FixedDirectory instance when the value is fixed File dir = valueFactory.create(); return new FixedDirectory(dir, resolver.newResolver(dir)); } }
public File file(Object path) { return fileResolver.resolve(path); }
public JavaExecHandleBuilder classpath(Object... paths) { classpath = classpath.plus(fileResolver.resolveFiles(paths)); return this; }
@Override public FileTree getAsFileTree() { return resolver.resolveFilesAsTree(this); }
private void applyScript(Object script) { URI scriptUri = resolver.resolveUri(script); TextResource resource = resourceLoader.loadUri("script", scriptUri); ScriptSource scriptSource = new TextResourceScriptSource(resource); ClassLoaderScope classLoaderScopeChild = classLoaderScope.createChild("script-" + scriptUri.toString()); ScriptHandler scriptHandler = scriptHandlerFactory.create(scriptSource, classLoaderScopeChild); ScriptPlugin configurer = configurerFactory.create(scriptSource, scriptHandler, classLoaderScopeChild, classLoaderScope, false); for (Object target : targets) { configurer.apply(target); } }
public ReadableResourceInternal bzip2(Object path) { return new Bzip2Archiver(fileOperations.getFileResolver().resolveResource(path)); }
public DefaultCopySpec(FileResolver resolver, Instantiator instantiator) { this.fileResolver = resolver; this.instantiator = instantiator; sourcePaths = new LinkedHashSet<Object>(); childSpecs = new ArrayList<CopySpecInternal>(); childSpecsInAdditionOrder = new ArrayList<CopySpecInternal>(); patternSet = resolver.getPatternSetFactory().create(); duplicatesStrategy = null; }
@Override protected RegularFile map(File file) { return new FixedFile(projectDir.fileResolver.resolve(file)); } };
@Override public void set(File dir) { File resolved = resolver.resolve(dir); set(new FixedDirectory(resolved, resolver.newResolver(resolved))); }
private Set<DirectoryTree> doGetSrcDirTrees() { Set<DirectoryTree> result = new LinkedHashSet<DirectoryTree>(); for (Object path : source) { if (path instanceof SourceDirectorySet) { SourceDirectorySet nested = (SourceDirectorySet) path; result.addAll(nested.getSrcDirTrees()); } else { for (File srcDir : fileResolver.resolveFiles(path)) { if (srcDir.exists() && !srcDir.isDirectory()) { throw new InvalidUserDataException(String.format("Source directory '%s' is not a directory.", srcDir)); } result.add(directoryFileTreeFactory.create(srcDir, patterns)); } } } return result; }