Skip to content

Refactor ConventionsPlugin class #20805

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Closed
wants to merge 4 commits into from
Closed

Refactor ConventionsPlugin class #20805

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
4 commits
Select commit Hold shift + click to select a range
b5b4b60
creating MavenPomConventions class extracted from private methods in …
mikesmithson Apr 2, 2020
8f2738a
moving Java related configuration to JavaConventions; moving file rel…
mikesmithson Apr 3, 2020
c07a044
issue #20805 - make changes per reviewer request
mikesmithson Apr 3, 2020
13e7406
issue #20805 - remove DocumentConventions class and inline all method…
mikesmithson Apr 3, 2020
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
251 changes: 8 additions & 243 deletions buildSrc/src/main/java/org/springframework/boot/build/ConventionsPlugin.java
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -16,283 +16,48 @@

package org.springframework.boot.build;

import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.URISyntaxException;
import java.net.URL;
import java.nio.charset.StandardCharsets;
import java.util.List;
import java.util.Map;
import java.util.TreeMap;
import java.util.function.Consumer;

import io.spring.javaformat.gradle.FormatTask;
import io.spring.javaformat.gradle.SpringJavaFormatPlugin;
import org.apache.maven.artifact.repository.MavenArtifactRepository;
import org.asciidoctor.gradle.jvm.AsciidoctorJPlugin;
import org.gradle.api.GradleException;
import org.gradle.api.Plugin;
import org.gradle.api.Project;
import org.gradle.api.artifacts.DependencySet;
import org.gradle.api.file.CopySpec;
import org.gradle.api.plugins.JavaBasePlugin;
import org.gradle.api.plugins.JavaPlugin;
import org.gradle.api.plugins.JavaPluginExtension;
import org.gradle.api.plugins.quality.CheckstyleExtension;
import org.gradle.api.plugins.quality.CheckstylePlugin;
import org.gradle.api.publish.PublishingExtension;
import org.gradle.api.publish.maven.MavenPom;
import org.gradle.api.publish.maven.MavenPomDeveloperSpec;
import org.gradle.api.publish.maven.MavenPomIssueManagement;
import org.gradle.api.publish.maven.MavenPomLicenseSpec;
import org.gradle.api.publish.maven.MavenPomOrganization;
import org.gradle.api.publish.maven.MavenPomScm;
import org.gradle.api.publish.maven.MavenPublication;
import org.gradle.api.publish.maven.plugins.MavenPublishPlugin;
import org.gradle.api.resources.TextResourceFactory;
import org.gradle.api.tasks.bundling.Jar;
import org.gradle.api.tasks.compile.JavaCompile;
import org.gradle.api.tasks.javadoc.Javadoc;
import org.gradle.api.tasks.testing.Test;
import org.gradle.testretry.TestRetryPlugin;
import org.gradle.testretry.TestRetryTaskExtension;

import org.springframework.boot.build.testing.TestFailuresPlugin;
import org.springframework.util.FileCopyUtils;

/**
* Plugin to apply conventions to projects that are part of Spring Boot's build.
* Conventions are applied in response to various plugins being applied.
*
* <p/>
*
* When the {@link JavaBasePlugin Java base plugin} is applied:
*
* <ul>
* <li>{@code sourceCompatibility} is set to {@code 1.8}
* <li>{@link SpringJavaFormatPlugin Spring Java Format}, {@link CheckstylePlugin
* Checkstyle}, {@link TestFailuresPlugin Test Failures}, and {@link TestRetryPlugin Test
* Retry} plugins are applied
* <li>{@link Test} tasks are configured to use JUnit Platform and use a max heap of 1024M
* <li>{@link JavaCompile}, {@link Javadoc}, and {@link FormatTask} tasks are configured
* to use UTF-8 encoding
* <li>{@link JavaCompile} tasks are configured to use {@code -parameters}
* <li>{@link Jar} tasks are configured to produce jars with LICENSE.txt and NOTICE.txt
* files and the following manifest entries:
* <ul>
* <li>{@code Automatic-Module-Name}
* <li>{@code Build-Jdk-Spec}
* <li>{@code Built-By}
* <li>{@code Implementation-Title}
* <li>{@code Implementation-Version}
* </ul>
* </ul>
*
* <p/>
* When the {@link JavaBasePlugin} is applied, the conventions in *
* {@link JavaConventions} are applied.
*
* When the {@link MavenPublishPlugin Maven Publish plugin} is applied:
*
* <ul>
* <li>If the {@code deploymentRepository} property has been set, a
* {@link MavenArtifactRepository Maven artifact repository} is configured to publish to
* it.
* <li>The poms of all {@link MavenPublication Maven publications} are customized to meet
* Maven Central's requirements.
* <li>If the {@link JavaPlugin Java plugin} has also been applied, creation of Javadoc
* and source jars is enabled.
* </ul>
*
* <p/>
* When the {@link MavenPublishPlugin} is applied, the conventions in
* {@link MavenPublishingConventions} are applied.
*
* When the {@link AsciidoctorJPlugin} is applied, the conventions in
* {@link AsciidoctorConventions} are applied.
*
* @author Andy Wilkinson
* @author Christoph Dreis
* @author Mike Smithson
Copy link
Member

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

The javadoc above should be updated to replace the list of actions when the MavenPublishPlugin is applied and to link to the new Maven conventions class instead.

*/
public class ConventionsPlugin implements Plugin<Project> {

@Override
public void apply(Project project) {
applyJavaConventions(project);
applyAsciidoctorConventions(project);
applyMavenPublishingConventions(project);
applyAsciidoctorConventions(project);
}

private void applyJavaConventions(Project project) {
project.getPlugins().withType(JavaBasePlugin.class, (java) -> {
project.getPlugins().apply(TestFailuresPlugin.class);
configureSpringJavaFormat(project);
project.setProperty("sourceCompatibility", "1.8");
project.getTasks().withType(JavaCompile.class, (compile) -> {
compile.getOptions().setEncoding("UTF-8");
withOptionalBuildJavaHome(project, (javaHome) -> {
compile.getOptions().setFork(true);
compile.getOptions().getForkOptions().setJavaHome(new File(javaHome));
compile.getOptions().getForkOptions().setExecutable(javaHome + "/bin/javac");
});
List<String> args = compile.getOptions().getCompilerArgs();
if (!args.contains("-parameters")) {
args.add("-parameters");
}
});
project.getTasks().withType(Javadoc.class, (javadoc) -> {
javadoc.getOptions().source("1.8").encoding("UTF-8");
withOptionalBuildJavaHome(project, (javaHome) -> javadoc.setExecutable(javaHome + "/bin/javadoc"));
});
project.getPlugins().apply(TestRetryPlugin.class);
project.getTasks().withType(Test.class, (test) -> {
withOptionalBuildJavaHome(project, (javaHome) -> test.setExecutable(javaHome + "/bin/java"));
test.useJUnitPlatform();
test.setMaxHeapSize("1024M");
project.getPlugins().withType(TestRetryPlugin.class, (testRetryPlugin) -> {
TestRetryTaskExtension testRetry = test.getExtensions().getByType(TestRetryTaskExtension.class);
testRetry.getFailOnPassedAfterRetry().set(true);
testRetry.getMaxRetries().set(3);
});
});
project.getTasks().withType(Jar.class, (jar) -> {
project.afterEvaluate((evaluated) -> {
jar.metaInf((metaInf) -> copyLegalFiles(project, metaInf));
jar.manifest((manifest) -> {
Map<String, Object> attributes = new TreeMap<>();
attributes.put("Automatic-Module-Name", project.getName().replace("-", "."));
attributes.put("Build-Jdk-Spec", project.property("sourceCompatibility"));
attributes.put("Built-By", "Spring");
attributes.put("Implementation-Title", project.getDescription());
attributes.put("Implementation-Version", project.getVersion());
manifest.attributes(attributes);
});
});
});
});
}

private void copyLegalFiles(Project project, CopySpec metaInf) {
copyNoticeFile(project, metaInf);
copyLicenseFile(project, metaInf);
}

private void copyNoticeFile(Project project, CopySpec metaInf) {
try {
InputStream notice = getClass().getClassLoader().getResourceAsStream("NOTICE.txt");
String noticeContent = FileCopyUtils.copyToString(new InputStreamReader(notice, StandardCharsets.UTF_8))
.replace("${version}", project.getVersion().toString());
TextResourceFactory resourceFactory = project.getResources().getText();
File file = createLegalFile(resourceFactory.fromString(noticeContent).asFile(), "NOTICE.txt");
metaInf.from(file);
}
catch (IOException ex) {
throw new GradleException("Failed to copy NOTICE.txt", ex);
}
}

private void copyLicenseFile(Project project, CopySpec metaInf) {
URL license = getClass().getClassLoader().getResource("LICENSE.txt");
try {
TextResourceFactory resourceFactory = project.getResources().getText();
File file = createLegalFile(resourceFactory.fromUri(license.toURI()).asFile(), "LICENSE.txt");
metaInf.from(file);
}
catch (URISyntaxException ex) {
throw new GradleException("Failed to copy LICENSE.txt", ex);
}
}

private File createLegalFile(File source, String filename) {
File legalFile = new File(source.getParentFile(), filename);
source.renameTo(legalFile);
return legalFile;
}

private void withOptionalBuildJavaHome(Project project, Consumer<String> consumer) {
String buildJavaHome = (String) project.findProperty("buildJavaHome");
if (buildJavaHome != null && !buildJavaHome.isEmpty()) {
consumer.accept(buildJavaHome);
}
}

private void configureSpringJavaFormat(Project project) {
project.getPlugins().apply(SpringJavaFormatPlugin.class);
project.getTasks().withType(FormatTask.class, (formatTask) -> formatTask.setEncoding("UTF-8"));
project.getPlugins().apply(CheckstylePlugin.class);
CheckstyleExtension checkstyle = project.getExtensions().getByType(CheckstyleExtension.class);
checkstyle.setToolVersion("8.29");
checkstyle.getConfigDirectory().set(project.getRootProject().file("src/checkstyle"));
String version = SpringJavaFormatPlugin.class.getPackage().getImplementationVersion();
DependencySet checkstyleDependencies = project.getConfigurations().getByName("checkstyle").getDependencies();
checkstyleDependencies
.add(project.getDependencies().create("io.spring.javaformat:spring-javaformat-checkstyle:" + version));
checkstyleDependencies
.add(project.getDependencies().create("io.spring.nohttp:nohttp-checkstyle:0.0.3.RELEASE"));
new JavaConventions().apply(project);
}

private void applyAsciidoctorConventions(Project project) {
new AsciidoctorConventions().apply(project);
}

private void applyMavenPublishingConventions(Project project) {
project.getPlugins().withType(MavenPublishPlugin.class).all((mavenPublish) -> {
PublishingExtension publishing = project.getExtensions().getByType(PublishingExtension.class);
if (project.hasProperty("deploymentRepository")) {
publishing.getRepositories().maven((mavenRepository) -> {
mavenRepository.setUrl(project.property("deploymentRepository"));
mavenRepository.setName("deployment");
});
}
publishing.getPublications().withType(MavenPublication.class)
.all((mavenPublication) -> customizePom(mavenPublication.getPom(), project));
project.getPlugins().withType(JavaPlugin.class).all((javaPlugin) -> {
JavaPluginExtension extension = project.getExtensions().getByType(JavaPluginExtension.class);
extension.withJavadocJar();
extension.withSourcesJar();
});
});
}

private void customizePom(MavenPom pom, Project project) {
pom.getUrl().set("https://projects.spring.io/spring-boot/#");
pom.getDescription().set(project.provider(project::getDescription));
pom.organization(this::customizeOrganization);
pom.licenses(this::customizeLicences);
pom.developers(this::customizeDevelopers);
pom.scm(this::customizeScm);
pom.issueManagement(this::customizeIssueManagement);
}

private void customizeOrganization(MavenPomOrganization organization) {
organization.getName().set("Pivotal Software, Inc.");
organization.getUrl().set("https://spring.io");
}

private void customizeLicences(MavenPomLicenseSpec licences) {
licences.license((licence) -> {
licence.getName().set("Apache License, Version 2.0");
licence.getUrl().set("http://www.apache.org/licenses/LICENSE-2.0");
});
}

private void customizeDevelopers(MavenPomDeveloperSpec developers) {
developers.developer((developer) -> {
developer.getName().set("Pivotal");
developer.getEmail().set("[email protected]");
developer.getOrganization().set("Pivotal Software, Inc.");
developer.getOrganizationUrl().set("https://www.spring.io");
});
}

private void customizeScm(MavenPomScm scm) {
scm.getConnection().set("scm:git:git://github.com/spring-projects/spring-boot.git");
scm.getDeveloperConnection().set("scm:git:ssh://[email protected]/spring-projects/spring-boot.git");
scm.getUrl().set("https://github.com/spring-projects/spring-boot");

}

private void customizeIssueManagement(MavenPomIssueManagement issueManagement) {
issueManagement.getSystem().set("GitHub");
issueManagement.getUrl().set("https://github.com/spring-projects/spring-boot/issues");
new MavenPublishingConventions().applyPublishingConventions(project);
}

}
Loading