@Override public void apply(final Project project) { DefaultTask javaTask = project.getTasks().create("javaTask", MyJavaTask.class); javaTask.setDescription("javaTask Demo"); DefaultTask javaXTask = project.getTasks().create("javaXTask", MyOtherJavaTask.class); javaXTask.setDescription("javaXTask Demo"); }
// @Todo: refactor this task configuration to extend a copy task and use replace tokens private void addCreateScriptsTask() { CreateStartScripts startScripts = project.getTasks().create(TASK_START_SCRIPTS_NAME, CreateStartScripts.class); startScripts.setDescription( "Creates OS specific scripts to run the project as a JVM application."); startScripts.setClasspath( project .getTasks() .getAt(JavaPlugin.JAR_TASK_NAME) .getOutputs() .getFiles() .plus(project.getConfigurations().getByName("runtime"))); startScripts .getConventionMapping() .map( "mainClassName", new Callable<Object>() { @Override public Object call() throws Exception { return pluginConvention.getMainClassName(); } }); startScripts .getConventionMapping() .map( "applicationName", new Callable<Object>() { @Override public Object call() throws Exception { return pluginConvention.getApplicationName(); } }); startScripts .getConventionMapping() .map( "outputDir", new Callable<Object>() { @Override public Object call() throws Exception { return new File(project.getBuildDir(), "scripts"); } }); startScripts .getConventionMapping() .map( "defaultJvmOpts", new Callable<Object>() { @Override public Object call() throws Exception { return pluginConvention.getApplicationDefaultJvmArgs(); } }); }
public void apply(Project project) { project.getExtensions().create("flyway", FlywayExtension.class); project.getTasks().create("flywayClean", FlywayCleanTask.class); project.getTasks().create("flywayInit", FlywayInitTask.class); project.getTasks().create("flywayMigrate", FlywayMigrateTask.class); project.getTasks().create("flywayValidate", FlywayValidateTask.class); project.getTasks().create("flywayInfo", FlywayInfoTask.class); project.getTasks().create("flywayRepair", FlywayRepairTask.class); }
@Test public void addsAnOsgiManifestToEachJar() { osgiPlugin.apply(project, new PluginRegistry(), null); Task task = project.getTasks().getByName(JavaPlugin.JAR_TASK_NAME); assertThat(task.property("osgi"), is(OsgiManifest.class)); task = project.getTasks().add("otherJar", Jar.class); assertThat(task.property("osgi"), is(OsgiManifest.class)); }
private void attachTasksToBinary( ClassDirectoryBinarySpecInternal binary, SourceSet sourceSet, Project target) { Task compileTask = target.getTasks().getByPath(sourceSet.getCompileJavaTaskName()); Task resourcesTask = target.getTasks().getByPath(sourceSet.getProcessResourcesTaskName()); Task classesTask = target.getTasks().getByPath(sourceSet.getClassesTaskName()); binary.getTasks().add(compileTask); binary.getTasks().add(resourcesTask); binary.getTasks().add(classesTask); binary.setBuildTask(classesTask); }
private void addRunTask() { JavaExec run = project.getTasks().create(TASK_RUN_NAME, JavaExec.class); run.setDescription("Runs this project as a JVM application"); run.setGroup(APPLICATION_GROUP); JavaPluginConvention javaPluginConvention = project.getConvention().getPlugin(JavaPluginConvention.class); run.setClasspath( javaPluginConvention .getSourceSets() .getByName(SourceSet.MAIN_SOURCE_SET_NAME) .getRuntimeClasspath()); run.getConventionMapping() .map( "main", new Callable<Object>() { @Override public Object call() throws Exception { return pluginConvention.getMainClassName(); } }); run.getConventionMapping() .map( "jvmArgs", new Callable<Object>() { @Override public Object call() throws Exception { return pluginConvention.getApplicationDefaultJvmArgs(); } }); }
private DefaultGradleProject<LaunchableGradleTask> buildHierarchy(Project project) { List<DefaultGradleProject<LaunchableGradleTask>> children = new ArrayList<DefaultGradleProject<LaunchableGradleTask>>(); for (Project child : project.getChildProjects().values()) { children.add(buildHierarchy(child)); } DefaultGradleProject<LaunchableGradleTask> gradleProject = new DefaultGradleProject<LaunchableGradleTask>() .setPath(project.getPath()) .setName(project.getName()) .setDescription(project.getDescription()) .setBuildDirectory(project.getBuildDir()) .setProjectDirectory(project.getProjectDir()) .setChildren(children); gradleProject.getBuildScript().setSourceFile(project.getBuildFile()); gradleProject.setTasks(tasks(gradleProject, (TaskContainerInternal) project.getTasks())); for (DefaultGradleProject child : children) { child.setParent(gradleProject); } return gradleProject; }
private void configureBuildDependents(Project project) { DefaultTask buildTask = project.getTasks().add(BUILD_DEPENDENTS_TASK_NAME, DefaultTask.class); buildTask.setDescription( "Assembles and tests this project and all projects that depend on it."); buildTask.setGroup(BasePlugin.BUILD_GROUP); buildTask.dependsOn(BUILD_TASK_NAME); }
private void configureJavaDoc(final Project project, final JavaPluginConvention convention) { project .getTasks() .withType( Javadoc.class, new Action<Javadoc>() { public void execute(Javadoc javadoc) { javadoc .getConventionMapping() .map( "destinationDir", new Callable<Object>() { public Object call() throws Exception { return new File(convention.getDocsDir(), "javadoc"); } }); javadoc .getConventionMapping() .map( "title", new Callable<Object>() { public Object call() throws Exception { return project .getExtensions() .getByType(ReportingExtension.class) .getApiDocTitle(); } }); } }); }
/** * Configures the classpath for Jacoco tasks using the 'jacocoAnt' configuration. Uses the version * information declared in 'toolVersion' of the Jacoco extension if no dependencies are explicitly * declared. * * @param extension the JacocoPluginExtension */ private void configureTaskClasspathDefaults(final JacocoPluginExtension extension) { final Configuration config = this.project.getConfigurations().getAt(ANT_CONFIGURATION_NAME); project .getTasks() .withType( JacocoBase.class, new Action<JacocoBase>() { @Override public void execute(JacocoBase task) { ((IConventionAware) task) .getConventionMapping() .map("jacocoClasspath", Callables.returning(config)); } }); config.defaultDependencies( new Action<DependencySet>() { @Override public void execute(DependencySet dependencies) { dependencies.add( project .getDependencies() .create("org.jacoco:org.jacoco.ant:" + extension.getToolVersion())); } }); }
private void configureTest(final Project project, final JavaPluginConvention convention) { project .getTasks() .withType( Test.class, new Action<Test>() { public void execute(Test test) { configureTestDefaults(test, project, convention); } }); project.afterEvaluate( new Action<Project>() { public void execute(Project project) { project .getTasks() .withType( Test.class, new Action<Test>() { public void execute(Test test) { overwriteIncludesIfSinglePropertyIsSet(test); overwriteDebugIfDebugPropertyIsSet(test); } }); } }); }
private void configureBuild(Project project) { DefaultTask buildTask = project.getTasks().add(BUILD_TASK_NAME, DefaultTask.class); buildTask.setDescription("Assembles and tests this project."); buildTask.setGroup(BasePlugin.BUILD_GROUP); buildTask.dependsOn(BasePlugin.ASSEMBLE_TASK_NAME); buildTask.dependsOn(CHECK_TASK_NAME); }
@Override public void apply(final Project project) { this.project = project; project.getPluginManager().apply(JavaPlugin.class); project.getPluginManager().apply(DistributionPlugin.class); addPluginConvention(); addRunTask(); addCreateScriptsTask(); Distribution distribution = ((DistributionContainer) project.getExtensions().getByName("distributions")) .getByName(DistributionPlugin.MAIN_DISTRIBUTION_NAME); ((IConventionAware) distribution) .getConventionMapping() .map( "baseName", new Callable<Object>() { @Override public Object call() throws Exception { return pluginConvention.getApplicationName(); } }); configureDistSpec(distribution.getContents()); configureInstallTask(project.getTasks().getAt(TASK_INSTALL_NAME)); }
private void configureGroovydoc(final Project project) { project .getTasks() .withType( Groovydoc.class, new Action<Groovydoc>() { public void execute(Groovydoc groovydoc) { groovydoc .getConventionMapping() .map( "groovyClasspath", new ConventionValue() { public Object getValue( Convention convention, IConventionAware conventionAwareObject) { return project .getConfigurations() .getByName(GROOVY_CONFIGURATION_NAME) .copy() .setTransitive(true); } }); groovydoc .getConventionMapping() .map( "destinationDir", new ConventionValue() { public Object getValue( Convention convention, IConventionAware conventionAwareObject) { return new File(java(convention).getDocsDir(), "groovydoc"); } }); groovydoc .getConventionMapping() .map( "docTitle", new ConventionValue() { public Object getValue( Convention convention, IConventionAware conventionAwareObject) { return convention .getPlugin(ReportingBasePluginConvention.class) .getApiDocTitle(); } }); groovydoc .getConventionMapping() .map( "windowTitle", new ConventionValue() { public Object getValue( Convention convention, IConventionAware conventionAwareObject) { return convention .getPlugin(ReportingBasePluginConvention.class) .getApiDocTitle(); } }); } }); }
private void configureCompileDefaults( final Project project, final JavaPluginConvention javaConvention) { project .getTasks() .withType( AbstractCompile.class, new Action<AbstractCompile>() { public void execute(final AbstractCompile compile) { ConventionMapping conventionMapping = compile.getConventionMapping(); conventionMapping.map( "sourceCompatibility", new Callable<Object>() { public Object call() throws Exception { return javaConvention.getSourceCompatibility().toString(); } }); conventionMapping.map( "targetCompatibility", new Callable<Object>() { public Object call() throws Exception { return javaConvention.getTargetCompatibility().toString(); } }); } }); project .getTasks() .withType( JavaCompile.class, new Action<JavaCompile>() { public void execute(final JavaCompile compile) { ConventionMapping conventionMapping = compile.getConventionMapping(); conventionMapping.map( "dependencyCacheDir", new Callable<Object>() { public Object call() throws Exception { return javaConvention.getDependencyCacheDir(); } }); } }); }
private void configureJacocoReportsDefaults(final JacocoPluginExtension extension) { project .getTasks() .withType( JacocoReport.class, new Action<JacocoReport>() { @Override public void execute(JacocoReport reportTask) { configureJacocoReportDefaults(extension, reportTask); } }); }
/** * Applies the Jacoco agent to all tasks of type {@code Test}. * * @param extension the extension to apply Jacoco with */ private void applyToDefaultTasks(final JacocoPluginExtension extension) { project .getTasks() .withType( Test.class, new Action<Test>() { @Override public void execute(Test task) { extension.applyTo(task); } }); }
private void _configureTasksBuildSoy(Project project, final Configuration soyConfiguration) { TaskContainer taskContainer = project.getTasks(); taskContainer.withType( BuildSoyTask.class, new Action<BuildSoyTask>() { @Override public void execute(BuildSoyTask buildSoyTask) { _configureTaskBuildSoyClasspath(buildSoyTask, soyConfiguration); } }); }
private JarOutputsModel getProjectInfo(Project project) { if (project.getConvention().findPlugin(JavaPluginConvention.class) == null) { return null; } List<JarOutput> result = new LinkedList<JarOutput>(); TaskCollection<? extends Jar> allJars = project.getTasks().withType(Jar.class); for (Jar jar : allJars) { result.add( new JarOutput(jar.getName(), jar.getArchivePath(), tryGetAllJarSourceSetNames(jar))); } return new JarOutputsModel(result); }
private CopySpec configureDistSpec(CopySpec distSpec) { Task jar = project.getTasks().getAt(JavaPlugin.JAR_TASK_NAME); Task startScripts = project.getTasks().getAt(TASK_START_SCRIPTS_NAME); CopySpec libChildSpec = project.copySpec(); libChildSpec.into("lib"); libChildSpec.from(jar); libChildSpec.from(project.getConfigurations().getByName("runtime")); CopySpec binChildSpec = project.copySpec(); binChildSpec.into("bin"); binChildSpec.from(startScripts); binChildSpec.setFileMode(0755); CopySpec childSpec = project.copySpec(); childSpec.from(project.file("src/dist")); childSpec.with(libChildSpec); childSpec.with(binChildSpec); distSpec.with(childSpec); distSpec.with(pluginConvention.getApplicationDistribution()); return distSpec; }
private void addDefaultReportTask(final JacocoPluginExtension extension, final Test task) { final JacocoReport reportTask = project .getTasks() .create( "jacoco" + StringUtils.capitalise(task.getName()) + "Report", JacocoReport.class); reportTask.executionData(task); reportTask.sourceSets( project .getConvention() .getPlugin(JavaPluginConvention.class) .getSourceSets() .getByName("main")); ConventionMapping taskMapping = ((IConventionAware) reportTask).getConventionMapping(); taskMapping .getConventionValue(reportTask.getReports(), "reports", false) .all( new Action<Report>() { @Override public void execute(final Report report) { ConventionMapping reportMapping = ((IConventionAware) report).getConventionMapping(); // reportMapping.map('enabled', Callables.returning(true)); if (report.getOutputType().equals(Report.OutputType.DIRECTORY)) { reportMapping.map( "destination", new Callable<File>() { @Override public File call() { return new File( extension.getReportsDir(), task.getName() + "/" + report.getName()); } }); } else { reportMapping.map( "destination", new Callable<File>() { @Override public File call() { return new File( extension.getReportsDir(), task.getName() + "/" + reportTask.getName() + "." + report.getName()); } }); } } }); }
private String _getAppJavadocGroupName(Project project) { String groupName = project.getDescription(); if (Validator.isNull(groupName)) { groupName = project.getName(); } TaskContainer taskContainer = project.getTasks(); WritePropertiesTask recordArtifactTask = (WritePropertiesTask) taskContainer.findByName(LiferayRelengPlugin.RECORD_ARTIFACT_TASK_NAME); if (recordArtifactTask != null) { String artifactURL = null; File artifactPropertiesFile = recordArtifactTask.getOutputFile(); if (artifactPropertiesFile.exists()) { Properties properties = GUtil.loadProperties(artifactPropertiesFile); artifactURL = properties.getProperty("artifact.url"); } if (Validator.isNotNull(artifactURL)) { int start = artifactURL.lastIndexOf('/') + 1; int end = artifactURL.lastIndexOf('.'); int pos = artifactURL.indexOf('-', start); String moduleName = artifactURL.substring(start, pos); String moduleVersion = artifactURL.substring(pos + 1, end); StringBuilder sb = new StringBuilder(); sb.append("Module "); sb.append(moduleName); sb.append(' '); sb.append(moduleVersion); sb.append(" - "); sb.append(groupName); groupName = sb.toString(); } } return groupName; }
private void createProcessResourcesTaskForBinary( final SourceSet sourceSet, JvmResourceSet resourceSet, final Project target) { Copy resourcesTask = target.getTasks().create(sourceSet.getProcessResourcesTaskName(), ProcessResources.class); resourcesTask.setDescription(String.format("Processes %s.", resourceSet)); new DslObject(resourcesTask) .getConventionMapping() .map( "destinationDir", new Callable<File>() { public File call() throws Exception { return sourceSet.getOutput().getResourcesDir(); } }); resourcesTask.from(resourceSet.getSource()); }
@TaskAction public void runApp() { final Project project = getProject(); final SourceSet main = ComputeMain.findMainSourceSet(project); final File outputDir = (main == null ? null : main.getOutput().getResourcesDir()); final Set<File> allResources = new LinkedHashSet<File>(); if (main != null) { allResources.addAll(main.getResources().getSrcDirs()); } project .getTasks() .withType( JavaExec.class, new Action<JavaExec>() { @Override public void execute(JavaExec exec) { ArrayList<File> files = new ArrayList<File>(exec.getClasspath().getFiles()); files.addAll(0, allResources); getLogger().info("Adding classpath: " + allResources); exec.setClasspath(new SimpleFileCollection(files)); if (exec.getMain() == null) { final String mainClass = findMainClass(main); exec.setMain(mainClass); exec.getConventionMapping() .map( "main", new Callable<String>() { @Override public String call() throws Exception { return mainClass; } }); getLogger().info("Found main: " + mainClass); } if (outputDir != null) { for (File directory : allResources) { FileUtils.removeDuplicatesFromOutputDirectory(outputDir, directory); } } exec.exec(); } }); }
private void _configureTasksTranspileJS( Project project, final DownloadNodeModuleTask downloadMetalCliTask, final ExecuteNpmTask npmInstallTask) { TaskContainer taskContainer = project.getTasks(); taskContainer.withType( TranspileJSTask.class, new Action<TranspileJSTask>() { @Override public void execute(TranspileJSTask transpileJSTask) { _configureTaskTranspileJS(transpileJSTask, downloadMetalCliTask, npmInstallTask); } }); }
private Upload createUploadTask( String name, final Configuration configuration, final Project project) { Upload upload = project.getTasks().create(name, Upload.class); upload.setDescription("Uploads all artifacts belonging to " + configuration); upload.setGroup(BasePlugin.UPLOAD_GROUP); upload.setConfiguration(configuration); upload.setUploadDescriptor(true); upload .getConventionMapping() .map( "descriptorDestination", new Callable<File>() { public File call() throws Exception { return new File(project.getBuildDir(), "ivy.xml"); } }); return upload; }
public void apply(final Project project) { RepositoryHandler repositories = publicationServices.createRepositoryHandler(); PublicationContainer publications = instantiator.newInstance(DefaultPublicationContainer.class, instantiator); // TODO Registering an extension should register it with the model registry as well final PublishingExtension extension = project .getExtensions() .create( PublishingExtension.NAME, DefaultPublishingExtension.class, repositories, publications); project.afterEvaluate( new Action<Project>() { public void execute(Project project) { for (Publication publication : extension.getPublications()) { PublicationInternal internalPublication = (PublicationInternal) publication; publicationRegistry.registerPublication( project.getPath(), new DefaultProjectPublication(internalPublication.getCoordinates())); } } }); ModelPath extensionModelPath = ModelPath.path(PublishingExtension.NAME); modelRules.register(extensionModelPath.toString(), extension); modelRules.rule( new ModelRule() { public void triggerDeferredConfigurables(PublishingExtension publishingExtension) { project.getExtensions().getByType(DefaultPublishingExtension.class); } }); Task publishLifecycleTask = project.getTasks().create(PUBLISH_LIFECYCLE_TASK_NAME); publishLifecycleTask.setDescription("Publishes all publications produced by this project."); publishLifecycleTask.setGroup(PUBLISH_TASK_GROUP); }
public Object configureDefaultOutputPathForJacocoMerge() { return project .getTasks() .withType( JacocoMerge.class, new Action<JacocoMerge>() { @Override public void execute(final JacocoMerge task) { ConventionMapping mapping = ((IConventionAware) task).getConventionMapping(); mapping.map( "destinationFile", new Callable<File>() { @Override public File call() { return new File( project.getBuildDir(), "/jacoco/" + task.getName() + ".exec"); } }); } }); }
private void createCompileJavaTaskForBinary( final SourceSet sourceSet, final JavaSourceSet javaSourceSet, Project target) { JavaCompile compileTask = target.getTasks().create(sourceSet.getCompileJavaTaskName(), JavaCompile.class); compileTask.setDescription(String.format("Compiles %s.", javaSourceSet)); compileTask.setSource(javaSourceSet.getSource()); compileTask.dependsOn(javaSourceSet); ConventionMapping conventionMapping = compileTask.getConventionMapping(); conventionMapping.map( "classpath", new Callable<Object>() { public Object call() throws Exception { return javaSourceSet.getCompileClasspath().getFiles(); } }); conventionMapping.map( "destinationDir", new Callable<Object>() { public Object call() throws Exception { return sourceSet.getOutput().getClassesDir(); } }); }
@TaskAction public void repackage() { Project project = getProject(); final SpringBootPluginExtension extension = project.getExtensions().getByType(SpringBootPluginExtension.class); final ProjectLibraries libraries = new ProjectLibraries(project); if (extension.getProvidedConfiguration() != null) { libraries.setProvidedConfigurationName(extension.getProvidedConfiguration()); } project .getTasks() .withType( Jar.class, new Action<Jar>() { @Override public void execute(Jar archive) { if ("".equals(archive.getClassifier())) { File file = archive.getArchivePath(); if (file.exists()) { Repackager repackager = new Repackager(file); repackager.setMainClass(extension.getMainClass()); if (extension.convertLayout() != null) { repackager.setLayout(extension.convertLayout()); } repackager.setBackupSource(extension.isBackupSource()); try { repackager.repackage(libraries); } catch (IOException ex) { throw new IllegalStateException(ex.getMessage(), ex); } } } } }); }