private void configureJavaExecTasks(final Project project, final String mainModuleName) { project.getTasks().withType(JavaExec.class).forEach(javaExec -> configureJavaExecTask(javaExec, mainModuleName)); }
@Override public T getByName(String name, Closure configureClosure) throws UnknownTaskException { return delegate.getByName(name, configureClosure); }
public static CreatePackageTask from(final Project project) { if (project == null) throw new IllegalArgumentException("project == null"); val tasks = project.getTasks().withType(CreatePackageTask.class); if (tasks == null || tasks.isEmpty()) { LOG.warn("Creating a \"createPackage\" task automatically. You should either do this " + "explicitly with the {} class, or by applying " + "the \"{}\" plugin", CreatePackageTask.class.getName(), CqPackagePlugin.NAME); return project.getTasks().create("createPackage", CreatePackageTask.class); } if (tasks.size() > 1) throw new IllegalArgumentException(project + " has more than one " + CreatePackageTask.class.getName()); return tasks.iterator().next(); }
private void createRunAllTask(Project project, String taskName, Class<? extends Task> taskClass) { project.subprojects(subProject -> { TaskCollection<?> tasks = subProject.getTasks().withType(taskClass); if (!tasks.isEmpty()) { Task runAllTask = project.getTasks().findByName(taskName); if (runAllTask == null) { runAllTask = project.getTasks().create(taskName); } runAllTask.dependsOn(tasks.toArray()); } }); }
@Override public void apply( Project project ) { project.getTasks().withType( JavaCompile.class ).configureEach( task -> { CompileOptions options = task.getOptions(); options.setAnnotationProcessorGeneratedSourcesDirectory( Paths.get( "build/generated/src" ).toFile() ); options.getCompilerArgs().addAll( Arrays.asList( "-parameters", "-Xlint:deprecation" ) ); } ); } }
@Override public void apply( Project project ) { project.getPluginManager().apply( ErrorPronePlugin.class ); project.getTasks().withType( JavaCompile.class ).whenTaskAdded( javaCompile -> { DependencyHandler deps = project.getDependencies(); deps.constraints( constraints -> { constraints.add( EP, "com.google.errorprone:error_prone_core:" + EPV ); } ); deps.add( COMPILE, "com.google.errorprone:error_prone_annotations:" + EPV ); } ); project.getTasks().withType( JavaCompile.class ).configureEach( task -> { CompileOptions options = task.getOptions(); options.setAnnotationProcessorGeneratedSourcesDirectory( Paths.get( "build/generated/src" ).toFile() ); options.getCompilerArgs().addAll( Arrays.asList( "-XepExcludedPaths:.*/build/generated/.*", "-Xep:MissingOverride:ERROR", "-Xep:Var:ERROR" ) ); } ); } }
@Override public Action<? super T> whenTaskAdded(Action<? super T> action) { return delegate.whenTaskAdded(action); }
TaskCollection<Jar> jarTasks = project.getTasks() .withType(Jar.class) .matching(jarTask -> jarTask.getClassifier().isEmpty() && jarTask.isEnabled()); if (jarTasks.isEmpty()) { return; .matching(generateTask -> isAncestorOf(generateTask.getProject(), project)) .forEach(generateTask -> generateTask.dependsOn(scanTask)); }); });
@Test public void testMinikubeExtensionSetProperties() { Project project = ProjectBuilder.builder().withProjectDir(tmp.getRoot()).build(); project.getPluginManager().apply(MinikubePlugin.class); MinikubeExtension ex = (MinikubeExtension) project.getExtensions().getByName("minikube"); ex.setMinikube("/custom/minikube/path"); TaskContainer t = project.getTasks(); TaskCollection<MinikubeTask> tc = t.withType(MinikubeTask.class); Assert.assertEquals(3, tc.size()); tc.forEach( minikubeTask -> { Assert.assertEquals(minikubeTask.getMinikube(), "/custom/minikube/path"); }); }
@Override public T findByName(String name) { return delegate.findByName(name); }
@Override public boolean isEmpty() { return delegate.isEmpty(); }
@Override public void apply( Project project ) { project.getPluginManager().apply( JavaLibraryPlugin.class ); DependencyHandler deps = project.getDependencies(); deps.add( TEST_IMPL, String.join( D, Junit.G, Junit.Api.A ) ); deps.add( TEST_IMPL, String.join( D, Junit.G, Junit.Param.A ) ); deps.add( TEST_RUN, String.join( D, Junit.G, Junit.Engine.A ) ); deps.add( TEST_IMPL, String.join( D, AssertJ.G, AssertJ.A ) ); project.getTasks().withType( Test.class ).configureEach( task -> { task.useJUnitPlatform(); task.testLogging( log -> log.info( info -> info.getEvents().add( TestLogEvent.PASSED ) ) ); task.reports( reports -> { reports.getJunitXml().setEnabled( true ); reports.getHtml().setEnabled( false ); } ); } ); project.getTasks().withType( JavaCompile.class ).configureEach( task -> { CompileOptions options = task.getOptions(); options.setAnnotationProcessorGeneratedSourcesDirectory( Paths.get( "build/generated/src" ).toFile() ); options.getCompilerArgs().addAll( Arrays.asList( "-parameters", "-Xlint:deprecation" ) ); } ); } }
@Override public void apply( Project project ) { project.getPluginManager().apply( ErrorPronePlugin.class ); project.getTasks().withType( JavaCompile.class ).whenTaskAdded( javaCompile -> { DependencyHandler deps = project.getDependencies(); deps.add( "errorprone", "com.google.errorprone:error_prone_core:" + EPV ); deps.add( COMPILE, "com.google.errorprone:error_prone_annotations:" + EPV ); } ); project.getTasks().withType( JavaCompile.class ).configureEach( task -> { CompileOptions options = task.getOptions(); options.setAnnotationProcessorGeneratedSourcesDirectory( Paths.get( "build/generated/src" ).toFile() ); ErrorProneOptions ep = ( (ExtensionAware) options ).getExtensions().getByType( ErrorProneOptions.class ); ep.check( "MissingOverride", CheckSeverity.ERROR ); ep.check( "Var", CheckSeverity.ERROR ); ep.setExcludedPaths( ".*/build/generated/.*" ); } ); } }
@Override public void whenTaskAdded(Closure closure) { delegate.whenTaskAdded(closure); }
private void addVaultFilter() { val addBundlesToFilterXmlTasks = getProject().getTasks().withType(AddBundlesToFilterXmlTask.class); if (addBundlesToFilterXmlTasks.isEmpty()) { filterXmlWithoutRewrite(); } else { if (addBundlesToFilterXmlTasks.size() > 1) { throw new InvalidUserDataException("There are more than one " + AddBundlesToFilterXmlTask.class.getName() + " tasks defined for " + getProject()); } else { val addBundlesToFilterXmlTask = addBundlesToFilterXmlTasks.iterator().next(); if (addBundlesToFilterXmlTask.isEnabled()) { try { val filterXmlFile = addBundlesToFilterXmlTask.getOutFile(); this.exclude("META-INF/vault/filter.xml"); this.into("META-INF/vault", it -> it.from(filterXmlFile)); } catch (IOException e) { throw new IllegalStateException("Could not read outFile from " + addBundlesToFilterXmlTask.getPath(), e); } } else { filterXmlWithoutRewrite(); } } } }
private void createDebugRule(DebugConfiguration configuration) { String prefix = configuration.getPrefix(); project.getTasks().addRule("Pattern: " + prefix + "<debuggableTask>", taskName -> { if (taskName.startsWith(prefix)) { String targetTaskName = uncapitalize(taskName.substring(prefix.length())); Task targetTask = debuggableTasks.findByName(targetTaskName); if (targetTask != null) { createDebugTask(taskName, targetTask, configuration); } } }); }
@Override public T getByName(String name) throws UnknownTaskException { return delegate.getByName(name); }
@Override public void all(Action<? super T> action) { delegate.all(action); }