@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));
}
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);
}
public DomainObjectSet<NativeBinary> getBinaries(NativeLibraryRequirement requirement) {
Project project = findProject(requirement);
LibraryContainer libraryContainer =
(LibraryContainer) project.getExtensions().findByName("libraries");
if (libraryContainer == null) {
throw new LibraryResolveException(
String.format("Project does not have a libraries container: '%s'", project.getPath()));
}
return libraryContainer.getByName(requirement.getLibraryName()).getBinaries();
}
public void apply(Project project) {
RepositoryHandler repositories =
artifactPublicationServicesFactory.create().getRepositoryHandler();
PublicationContainer publications =
instantiator.newInstance(DefaultPublicationContainer.class, instantiator);
project
.getExtensions()
.create(
PublishingExtension.NAME, DefaultPublishingExtension.class, repositories, publications);
}
@Override
public void apply(Project project) {
project.getExtensions().create(BugVMPluginExtension.NAME, BugVMPluginExtension.class, project);
project.task(
Collections.singletonMap("type", IPhoneSimulatorTask.class), "launchIPhoneSimulator");
project.task(Collections.singletonMap("type", IPadSimulatorTask.class), "launchIPadSimulator");
project.task(Collections.singletonMap("type", IOSDeviceTask.class), "launchIOSDevice");
project.task(Collections.singletonMap("type", ConsoleTask.class), "launchConsole");
project.task(Collections.singletonMap("type", ArchiveTask.class), "createIPA");
project.task(Collections.singletonMap("type", ArchiveTask.class), "bugvmArchive");
project.task(Collections.singletonMap("type", InstallTask.class), "bugvmInstall");
}
@TaskAction
public void report() {
Project project = getProject();
StyledTextOutput textOutput = getTextOutputFactory().create(ComponentReport.class);
ComponentReportRenderer renderer = new ComponentReportRenderer(getFileResolver());
renderer.setOutput(textOutput);
renderer.startProject(project);
Collection<ProjectComponent> components = new ArrayList<ProjectComponent>();
ProjectComponentContainer projectComponents =
project.getExtensions().findByType(ProjectComponentContainer.class);
if (projectComponents != null) {
components.addAll(projectComponents);
}
try {
TestSuiteContainer testSuites =
getModelRegistry().get(ModelReference.of("testSuites", TestSuiteContainer.class));
components.addAll(testSuites);
} catch (IllegalStateException e) {
// TODO - need a better contract here
// Ignore for now
}
renderer.renderComponents(components);
ProjectSourceSet sourceSets = project.getExtensions().findByType(ProjectSourceSet.class);
if (sourceSets != null) {
renderer.renderSourceSets(sourceSets);
}
BinaryContainer binaries = project.getExtensions().findByType(BinaryContainer.class);
if (binaries != null) {
renderer.renderBinaries(binaries);
}
renderer.completeProject(project);
renderer.complete();
}
@Override
public void apply(Project project) {
project.getPlugins().apply(DependencyManagementPlugin.class);
DependencyManagementExtension dependencyManagement =
project.getExtensions().findByType(DependencyManagementExtension.class);
dependencyManagement.imports(
new Action<ImportsHandler>() {
@Override
public void execute(ImportsHandler importsHandler) {
importsHandler.mavenBom(SPRING_BOOT_BOM);
}
});
}
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);
}
@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);
}
}
}
}
});
}
@Override
public void apply(Project target) {
target.getExtensions().create("generator", GeneratorPluginExtension.class);
target.task("javaTask");
}
private AmazonRDS initClient() {
AwsPluginExtension aws = project.getExtensions().getByType(AwsPluginExtension.class);
AmazonRDSClient client = aws.createClient(AmazonRDSClient.class, profileName);
client.setRegion(aws.getActiveRegion(region));
return client;
}
private void configureSourceSetDefaults(final JavaPluginConvention pluginConvention) {
final Project project = pluginConvention.getProject();
final ProjectSourceSet projectSourceSet =
project.getExtensions().getByType(ProjectSourceSet.class);
pluginConvention
.getSourceSets()
.all(
new Action<SourceSet>() {
public void execute(final SourceSet sourceSet) {
ConventionMapping outputConventionMapping =
((IConventionAware) sourceSet.getOutput()).getConventionMapping();
ConfigurationContainer configurations = project.getConfigurations();
defineConfigurationsForSourceSet(sourceSet, configurations);
definePathsForSourceSet(sourceSet, outputConventionMapping, project);
sourceSet.compiledBy(sourceSet.getClassesTaskName());
Classpath compileClasspath = new SourceSetCompileClasspath(sourceSet);
DefaultJavaSourceSet javaSourceSet =
instantiator.newInstance(
DefaultJavaSourceSet.class,
"java",
sourceSet.getName(),
sourceSet.getJava(),
compileClasspath);
projectSourceSet.add(javaSourceSet);
JvmResourceSet resourceSet =
instantiator.newInstance(
DefaultJvmResourceSet.class,
"resources",
sourceSet.getName(),
sourceSet.getResources());
projectSourceSet.add(resourceSet);
createProcessResourcesTaskForBinary(sourceSet, resourceSet, project);
createCompileJavaTaskForBinary(sourceSet, javaSourceSet, project);
createBinaryLifecycleTask(sourceSet, project);
ClassDirectoryBinarySpecInternal binary =
instantiator.newInstance(
DefaultClassDirectoryBinarySpec.class,
String.format("%sClasses", sourceSet.getName()),
sourceSet,
javaToolChain,
DefaultJavaPlatform.current(),
instantiator,
taskFactory);
binary.addSourceSet(javaSourceSet);
binary.addSourceSet(resourceSet);
BinaryContainer binaryContainer =
project.getExtensions().getByType(BinaryContainer.class);
binaryContainer.add(binary);
attachTasksToBinary(binary, sourceSet, project);
}
});
}
private void configureSourceSetDefaults(final JavaPluginConvention pluginConvention) {
final Project project = pluginConvention.getProject();
final ProjectSourceSet projectSourceSet =
project.getExtensions().getByType(ProjectSourceSet.class);
pluginConvention
.getSourceSets()
.all(
new Action<SourceSet>() {
public void execute(final SourceSet sourceSet) {
ConventionMapping outputConventionMapping =
((IConventionAware) sourceSet.getOutput()).getConventionMapping();
ConfigurationContainer configurations = project.getConfigurations();
Configuration compileConfiguration =
configurations.findByName(sourceSet.getCompileConfigurationName());
if (compileConfiguration == null) {
compileConfiguration =
configurations.add(sourceSet.getCompileConfigurationName());
}
compileConfiguration.setVisible(false);
compileConfiguration.setDescription(
String.format("Classpath for compiling the %s sources.", sourceSet.getName()));
Configuration runtimeConfiguration =
configurations.findByName(sourceSet.getRuntimeConfigurationName());
if (runtimeConfiguration == null) {
runtimeConfiguration =
configurations.add(sourceSet.getRuntimeConfigurationName());
}
runtimeConfiguration.setVisible(false);
runtimeConfiguration.extendsFrom(compileConfiguration);
runtimeConfiguration.setDescription(
String.format(
"Classpath for running the compiled %s classes.", sourceSet.getName()));
sourceSet.setCompileClasspath(compileConfiguration);
sourceSet.setRuntimeClasspath(sourceSet.getOutput().plus(runtimeConfiguration));
outputConventionMapping.map(
"classesDir",
new Callable<Object>() {
public Object call() throws Exception {
String classesDirName = String.format("classes/%s", sourceSet.getName());
return new File(project.getBuildDir(), classesDirName);
}
});
outputConventionMapping.map(
"resourcesDir",
new Callable<Object>() {
public Object call() throws Exception {
String classesDirName = String.format("resources/%s", sourceSet.getName());
return new File(project.getBuildDir(), classesDirName);
}
});
sourceSet.getJava().srcDir(String.format("src/%s/java", sourceSet.getName()));
sourceSet
.getResources()
.srcDir(String.format("src/%s/resources", sourceSet.getName()));
sourceSet.compiledBy(sourceSet.getClassesTaskName());
FunctionalSourceSet functionalSourceSet =
projectSourceSet.create(sourceSet.getName());
Classpath compileClasspath = new SourceSetCompileClasspath(sourceSet);
DefaultJavaSourceSet javaSourceSet =
instantiator.newInstance(
DefaultJavaSourceSet.class,
"java",
sourceSet.getJava(),
compileClasspath,
functionalSourceSet);
functionalSourceSet.add(javaSourceSet);
ResourceSet resourceSet =
instantiator.newInstance(
DefaultResourceSet.class,
"resources",
sourceSet.getResources(),
functionalSourceSet);
functionalSourceSet.add(resourceSet);
JvmBinaryContainer jvmBinaryContainer =
project.getPlugins().getPlugin(JvmLanguagePlugin.class).getJvmBinaryContainer();
ClassDirectoryBinary binary =
jvmBinaryContainer.create(sourceSet.getName(), ClassDirectoryBinary.class);
ConventionMapping conventionMapping = new DslObject(binary).getConventionMapping();
conventionMapping.map(
"classesDir",
new Callable<File>() {
public File call() throws Exception {
return sourceSet.getOutput().getClassesDir();
}
});
conventionMapping.map(
"resourcesDir",
new Callable<File>() {
public File call() throws Exception {
return sourceSet.getOutput().getResourcesDir();
}
});
binary.getSource().add(javaSourceSet);
binary.getSource().add(resourceSet);
binary.getClassesTask().dependsOn(sourceSet.getOutput().getDirs());
}
});
}
public void apply(Project project) {
project.getPluginManager().apply(AwsPlugin.class);
project
.getExtensions()
.create(AmazonRDSPluginExtension.NAME, AmazonRDSPluginExtension.class, project);
}