@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);
}
}
}
}
});
}
