Overhaul gradle build

- Focus of this commit is to have modern gradle build.
- Migrate most of a plugin configurations from dsl
  into buildSrc.
- This fixes issues with existing docs build.
- Allows to sign files so that we have that part
  done for central in a build.
- We can skip publishing samples.
- We're able to share similar logic for modules
  which are meant for publish or just being samples.
- It's easier to upgrade gradle versions without
  getting various build issues.
- Relates #1143

buildSrc/build.gradle

@@ -1,17 +1,58 @@
 plugins {
-	id 'java-gradle-plugin'
+	id "java-gradle-plugin"
+	id "java"
 }
 
+sourceCompatibility = JavaVersion.VERSION_17;
+
 repositories {
-	mavenCentral()
 	gradlePluginPortal()
+	mavenCentral()
+	maven { url 'https://repo.spring.io/plugins-release/' }
+	maven { url "https://repo.spring.io/snapshot" }
+}
+
+ext {
+	def propertiesFile = new File(new File("$projectDir").parentFile, "gradle.properties")
+	propertiesFile.withInputStream {
+		def properties = new Properties()
+		properties.load(it)
+		set("springBootVersion", properties["springBootVersion"])
+	}
+}
+
+dependencies {
+	implementation(platform("org.springframework.boot:spring-boot-dependencies:${springBootVersion}"))
+	implementation("org.springframework:spring-core")
+	implementation 'org.asciidoctor:asciidoctor-gradle-jvm:3.3.2'
+	implementation 'org.jfrog.buildinfo:build-info-extractor-gradle:4.29.0'
 }
 
 gradlePlugin {
 	plugins {
-		optionalDependenciesPlugin {
-			id = "org.springframework.statemachine.optional-dependencies"
-			implementationClass = "org.springframework.statemachine.gradle.OptionalDependenciesPlugin"
+		modulePlugin {
+			id = "org.springframework.statemachine.module"
+			implementationClass = "org.springframework.statemachine.gradle.ModulePlugin"
+		}
+		starterPlugin {
+			id = "org.springframework.statemachine.starter"
+			implementationClass = "org.springframework.statemachine.gradle.StarterPlugin"
+		}
+		bomPlugin {
+			id = "org.springframework.statemachine.bom"
+			implementationClass = "org.springframework.statemachine.gradle.BomPlugin"
+		}
+		docsPlugin {
+			id = "org.springframework.statemachine.docs"
+			implementationClass = "org.springframework.statemachine.gradle.DocsPlugin"
+		}
+		distPlugin {
+			id = "org.springframework.statemachine.root"
+			implementationClass = "org.springframework.statemachine.gradle.RootPlugin"
+		}
+		samplePlugin {
+			id = "org.springframework.statemachine.sample"
+			implementationClass = "org.springframework.statemachine.gradle.SamplePlugin"
 		}
 	}
 }

buildSrc/src/main/java/org/springframework/statemachine/gradle/ArtifactoryConventions.java

@@ -0,0 +1,74 @@
+/*
+ * Copyright 2022 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.statemachine.gradle;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import org.gradle.api.Project;
+import org.gradle.api.Task;
+import org.gradle.api.plugins.PluginManager;
+import org.gradle.api.publish.tasks.GenerateModuleMetadata;
+import org.jfrog.build.extractor.clientConfiguration.ArtifactSpec;
+import org.jfrog.build.extractor.clientConfiguration.ArtifactSpecs;
+import org.jfrog.gradle.plugin.artifactory.ArtifactoryPlugin;
+import org.jfrog.gradle.plugin.artifactory.task.ArtifactoryTask;
+
+/**
+ * @author Janne Valkealahti
+ */
+public class ArtifactoryConventions {
+
+	void apply(Project project) {
+		PluginManager pluginManager = project.getPluginManager();
+		pluginManager.apply(ArtifactoryPlugin.class);
+
+		project.getTasks().withType(GenerateModuleMetadata.class, metadata -> {
+			metadata.setEnabled(false);
+		});
+
+		project.getPlugins().withType(ArtifactoryPlugin.class, artifactory -> {
+			Task task = project.getTasks().findByName(ArtifactoryTask.ARTIFACTORY_PUBLISH_TASK_NAME);
+			if (task != null) {
+				ArtifactoryTask aTask = (ArtifactoryTask) task;
+				aTask.setCiServerBuild();
+				// bom is not a java project so plugin doesn't
+				// add defaults for publications.
+				aTask.publications("mavenJava");
+				aTask.publishConfigs("archives");
+
+				// plugin is difficult to work with, use this hack
+				// to set props before task does its real work
+				task.doFirst(t -> {
+					// this needs mods if we ever have zips other than
+					// docs zip having asciidoc/javadoc.
+					ArtifactoryTask at = (ArtifactoryTask) t;
+					ArtifactSpecs artifactSpecs = at.getArtifactSpecs();
+					Map<String, String> propsMap = new HashMap<>();
+					propsMap.put("zip.deployed", "false");
+					propsMap.put("zip.type", "docs");
+					ArtifactSpec spec = ArtifactSpec.builder()
+						.artifactNotation("*:*:*:*@zip")
+						// archives is manually set for zip in root plugin
+						.configuration("archives")
+						.properties(propsMap)
+						.build();
+					artifactSpecs.add(spec);
+				});
+			}
+		});
+	}
+}

buildSrc/src/main/java/org/springframework/statemachine/gradle/BomPlugin.java

@@ -0,0 +1,47 @@
+/*
+ * Copyright 2022 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.statemachine.gradle;
+
+import org.gradle.api.Plugin;
+import org.gradle.api.Project;
+import org.gradle.api.artifacts.dsl.DependencyConstraintHandler;
+import org.gradle.api.plugins.JavaPlatformPlugin;
+import org.gradle.api.plugins.PluginManager;
+
+/**
+ * @author Janne Valkealahti
+ */
+class BomPlugin implements Plugin<Project> {
+
+	@Override
+	public void apply(Project project) {
+		PluginManager pluginManager = project.getPluginManager();
+		pluginManager.apply(SpringMavenPlugin.class);
+		pluginManager.apply(JavaPlatformPlugin.class);
+		new ArtifactoryConventions().apply(project);
+
+		// bom should have main modules user can consume
+		DependencyConstraintHandler constraints = project.getDependencies().getConstraints();
+		project.getRootProject().getAllprojects().forEach(p -> {
+			p.getPlugins().withType(ModulePlugin.class, m -> {
+				constraints.add("api", p);
+			});
+			p.getPlugins().withType(StarterPlugin.class, m -> {
+				constraints.add("api", p);
+			});
+		});
+	}
+}

buildSrc/src/main/java/org/springframework/statemachine/gradle/DocsPlugin.java

@@ -0,0 +1,214 @@
+/*
+ * Copyright 2022-2023 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.statemachine.gradle;
+
+import java.io.File;
+import java.time.LocalDate;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import org.asciidoctor.gradle.base.AsciidoctorAttributeProvider;
+import org.asciidoctor.gradle.jvm.AbstractAsciidoctorTask;
+import org.asciidoctor.gradle.jvm.AsciidoctorJExtension;
+import org.asciidoctor.gradle.jvm.AsciidoctorJPlugin;
+import org.asciidoctor.gradle.jvm.AsciidoctorTask;
+import org.gradle.api.Action;
+import org.gradle.api.Plugin;
+import org.gradle.api.Project;
+import org.gradle.api.Task;
+import org.gradle.api.plugins.JavaLibraryPlugin;
+import org.gradle.api.plugins.JavaPlugin;
+import org.gradle.api.plugins.PluginManager;
+import org.gradle.api.publish.tasks.GenerateModuleMetadata;
+import org.gradle.api.tasks.PathSensitivity;
+import org.gradle.api.tasks.Sync;
+import org.springframework.util.StringUtils;
+
+/**
+ * @author Janne Valkealahti
+ */
+class DocsPlugin implements Plugin<Project> {
+
+	private static final String ASCIIDOCTORJ_VERSION = "2.4.3";
+	private static final String EXTENSIONS_CONFIGURATION_NAME = "asciidoctorExtensions";
+
+	@Override
+	public void apply(Project project) {
+		PluginManager pluginManager = project.getPluginManager();
+		pluginManager.apply(JavaPlugin.class);
+		pluginManager.apply(JavaLibraryPlugin.class);
+		pluginManager.apply(ManagementConfigurationPlugin.class);
+		pluginManager.apply(SpringMavenPlugin.class);
+		pluginManager.apply(AsciidoctorJPlugin.class);
+
+		ExtractVersionConstraints dependencyVersions = project.getTasks().create("dependencyVersions",
+			ExtractVersionConstraints.class, task -> {
+				task.enforcedPlatform(":spring-statemachine-platform");
+			});
+
+		project.getPlugins().withType(AsciidoctorJPlugin.class, (asciidoctorPlugin) -> {
+			// makeAllWarningsFatal(project);
+			upgradeAsciidoctorJVersion(project);
+			createAsciidoctorExtensionsConfiguration(project);
+			project.getTasks()
+				.withType(AbstractAsciidoctorTask.class,
+						(asciidoctorTask) -> configureAsciidoctorTask(project, asciidoctorTask, dependencyVersions));
+		});
+		project.getTasks().withType(GenerateModuleMetadata.class, metadata -> {
+			metadata.setEnabled(false);
+		});
+	}
+
+	private void upgradeAsciidoctorJVersion(Project project) {
+		project.getExtensions().getByType(AsciidoctorJExtension.class).setVersion(ASCIIDOCTORJ_VERSION);
+	}
+
+	private void createAsciidoctorExtensionsConfiguration(Project project) {
+		project.getConfigurations().create(EXTENSIONS_CONFIGURATION_NAME, (configuration) -> {
+			configuration.getDependencies()
+				.add(project.getDependencies()
+					.create("io.spring.asciidoctor.backends:spring-asciidoctor-backends:0.0.5"));
+		});
+	}
+
+	private void configureAsciidoctorTask(Project project, AbstractAsciidoctorTask asciidoctorTask, ExtractVersionConstraints dependencyVersions) {
+		asciidoctorTask.configurations(EXTENSIONS_CONFIGURATION_NAME);
+		configureCommonAttributes(project, asciidoctorTask, dependencyVersions);
+		configureOptions(asciidoctorTask);
+		asciidoctorTask.baseDirFollowsSourceDir();
+		createSyncDocumentationSourceTask(project, asciidoctorTask, dependencyVersions);
+		if (asciidoctorTask instanceof AsciidoctorTask) {
+			AsciidoctorTask task = (AsciidoctorTask)asciidoctorTask;
+			task.outputOptions((outputOptions) -> outputOptions.backends("spring-html"));
+		}
+	}
+
+	private void configureOptions(AbstractAsciidoctorTask asciidoctorTask) {
+		asciidoctorTask.options(Collections.singletonMap("doctype", "book"));
+	}
+
+	private Sync createSyncDocumentationSourceTask(Project project, AbstractAsciidoctorTask asciidoctorTask, ExtractVersionConstraints dependencyVersions) {
+		Sync syncDocumentationSource = project.getTasks()
+			.create("syncDocumentationSourceFor" + StringUtils.capitalize(asciidoctorTask.getName()), Sync.class);
+		syncDocumentationSource.preserve(filter -> {
+			filter.include("**/*");
+		});
+		File syncedSource = new File(project.getBuildDir(), "docs/src/" + asciidoctorTask.getName());
+		syncDocumentationSource.setDestinationDir(syncedSource);
+		// syncDocumentationSource.from("src/main/");
+		syncDocumentationSource.from("src/reference/");
+		asciidoctorTask.dependsOn(syncDocumentationSource);
+		asciidoctorTask.dependsOn(dependencyVersions);
+		Sync snippetsResources = createSnippetsResourcesTask(project);
+		asciidoctorTask.dependsOn(snippetsResources);
+		asciidoctorTask.getInputs()
+			.dir(syncedSource)
+			.withPathSensitivity(PathSensitivity.RELATIVE)
+			.withPropertyName("synced source");
+		asciidoctorTask.setSourceDir(project.relativePath(new File(syncedSource, "asciidoc/")));
+		return syncDocumentationSource;
+	}
+
+	private Sync createSnippetsResourcesTask(Project project) {
+		List<String> sources = Arrays.asList(
+			"spring-statemachine-core/src/test/java/org/springframework/statemachine/docs",
+			"spring-statemachine-test/src/test/java/org/springframework/statemachine/test/docs",
+			"spring-statemachine-recipes/src/test/java/org/springframework/statemachine/recipes/docs",
+			"spring-statemachine-zookeeper/src/test/java/org/springframework/statemachine/zookeeper/docs",
+			"spring-statemachine-uml/src/test/java/org/springframework/statemachine/uml/docs",
+			"spring-statemachine-uml/src/test/resources/org/springframework/statemachine/uml/docs",
+			"spring-statemachine-data/jpa/src/test/java/org/springframework/statemachine/data/jpa/docs",
+			"spring-statemachine-data/redis/src/test/java/org/springframework/statemachine/data/redis/docs",
+			"spring-statemachine-data/mongodb/src/test/java/org/springframework/statemachine/data/mongodb/docs",
+			"spring-statemachine-samples/src/main/java/",
+			"spring-statemachine-samples/washer/src/main/java/",
+			"spring-statemachine-samples/tasks/src/main/java/",
+			"spring-statemachine-samples/turnstile/src/main/java/",
+			"spring-statemachine-samples/turnstilereactive/src/main/java/",
+			"spring-statemachine-samples/showcase/src/main/java/",
+			"spring-statemachine-samples/cdplayer/src/main/java/",
+			"spring-statemachine-samples/persist/src/main/java/",
+			"spring-statemachine-samples/zookeeper/src/main/java/",
+			"spring-statemachine-samples/security/src/main/java/",
+			"spring-statemachine-samples/eventservice/src/main/java/",
+			"spring-statemachine-samples/datajpa/src/main/java/",
+			"spring-statemachine-samples/datajpa/src/main/resources/",
+			"spring-statemachine-samples/datajpamultipersist/src/main/java/",
+			"spring-statemachine-samples/datajpamultipersist/src/main/resources/",
+			"spring-statemachine-samples/datapersist/src/main/java/",
+			"spring-statemachine-samples/monitoring/src/main/java/");
+		Sync sync = project.getTasks().create("snippetResources", Sync.class, s -> {
+			for (String source : sources) {
+				s.from(new File(project.getRootProject().getRootDir(), source), spec -> {
+					spec.include("**/*.java", "**/*.uml", "**/*.json");
+				});
+			}
+			s.preserve(filter -> {
+				filter.include("**/*");
+			});
+			File destination = new File(project.getBuildDir(), "docs/src/asciidoctor/asciidoc/samples");
+			s.into(destination);
+		});
+		return sync;
+	}
+
+	private void configureCommonAttributes(Project project, AbstractAsciidoctorTask asciidoctorTask,
+			ExtractVersionConstraints dependencyVersions) {
+		asciidoctorTask.doFirst(new Action<Task>() {
+
+			@Override
+			public void execute(Task arg0) {
+				asciidoctorTask.getAttributeProviders().add(new AsciidoctorAttributeProvider() {
+					@Override
+					public Map<String, Object> getAttributes() {
+						Map<String, String> versionConstraints = dependencyVersions.getVersionConstraints();
+						Map<String, Object> attrs = new HashMap<>();
+						attrs.put("spring-version", versionConstraints.get("org.springframework:spring-core"));
+						attrs.put("spring-boot-version", versionConstraints.get("org.springframework.boot:spring-boot"));
+						return attrs;
+					}
+				});
+			}
+		});
+
+		Map<String, Object> attributes = new HashMap<>();
+		attributes.put("toc", "left");
+		attributes.put("icons", "font");
+		attributes.put("idprefix", "");
+		attributes.put("idseparator", "-");
+		attributes.put("docinfo", "shared");
+		attributes.put("sectanchors", "");
+		attributes.put("sectnums", "");
+		attributes.put("today-year", LocalDate.now().getYear());
+		attributes.put("snippets", "docs");
+
+		asciidoctorTask.getAttributeProviders().add(new AsciidoctorAttributeProvider() {
+			@Override
+			public Map<String, Object> getAttributes() {
+				Object version = project.getVersion();
+				Map<String, Object> attrs = new HashMap<>();
+				if (version != null && version.toString() != Project.DEFAULT_VERSION) {
+					attrs.put("project-version", version);
+				}
+				return attrs;
+			}
+		});
+		asciidoctorTask.attributes(attributes);
+	}
+}

buildSrc/src/main/java/org/springframework/statemachine/gradle/EclipseConventions.java

@@ -0,0 +1,59 @@
+/*
+ * Copyright 2024 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.statemachine.gradle;
+
+import org.gradle.api.Project;
+import org.gradle.plugins.ide.api.XmlFileContentMerger;
+import org.gradle.plugins.ide.eclipse.EclipsePlugin;
+import org.gradle.plugins.ide.eclipse.model.AbstractClasspathEntry;
+import org.gradle.plugins.ide.eclipse.model.Classpath;
+import org.gradle.plugins.ide.eclipse.model.ClasspathEntry;
+import org.gradle.plugins.ide.eclipse.model.EclipseClasspath;
+import org.gradle.plugins.ide.eclipse.model.EclipseModel;
+
+class EclipseConventions {
+
+	void apply(Project project) {
+		project.getPlugins().withType(EclipsePlugin.class, (eclipse) -> {
+			EclipseModel eclipseModel = project.getExtensions().getByType(EclipseModel.class);
+			eclipseModel.classpath(this::configureClasspath);
+		});
+	}
+
+	private void configureClasspath(EclipseClasspath classpath) {
+		classpath.file(this::configureClasspathFile);
+	}
+
+	private void configureClasspathFile(XmlFileContentMerger merger) {
+		merger.whenMerged((content) -> {
+			if (content instanceof Classpath) {
+				Classpath classpath = (Classpath) content;
+				for (ClasspathEntry entry : classpath.getEntries()) {
+					if (entry instanceof AbstractClasspathEntry) {
+						AbstractClasspathEntry ace = (AbstractClasspathEntry) entry;
+						Object value = ace.getEntryAttributes().get("test");
+						if (value instanceof String) {
+							if (Boolean.parseBoolean((String) value)) {
+								ace.getEntryAttributes().put("test", "false");
+							}
+						}
+					}
+				}
+			}
+		});
+	}
+
+}

buildSrc/src/main/java/org/springframework/statemachine/gradle/ExtractVersionConstraints.java

@@ -0,0 +1,154 @@
+package org.springframework.statemachine.gradle;
+
+import java.io.Serializable;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.TreeMap;
+import java.util.TreeSet;
+
+import org.gradle.api.DefaultTask;
+import org.gradle.api.artifacts.ComponentMetadataDetails;
+import org.gradle.api.artifacts.Configuration;
+import org.gradle.api.artifacts.DependencyConstraint;
+import org.gradle.api.artifacts.DependencyConstraintMetadata;
+import org.gradle.api.artifacts.dsl.DependencyHandler;
+import org.gradle.api.tasks.Internal;
+import org.gradle.api.tasks.TaskAction;
+
+/**
+ * @author Janne Valkealahti
+ */
+class ExtractVersionConstraints extends DefaultTask {
+
+	private final Configuration configuration;
+
+	private final Map<String, String> versionConstraints = new TreeMap<>();
+
+	private final Set<ConstrainedVersion> constrainedVersions = new TreeSet<>();
+
+	private final Set<VersionProperty> versionProperties = new TreeSet<>();
+
+	private final List<String> projectPaths = new ArrayList<>();
+
+	public ExtractVersionConstraints() {
+		DependencyHandler dependencies = getProject().getDependencies();
+		this.configuration = getProject().getConfigurations().create(getName());
+		dependencies.getComponents().all(this::processMetadataDetails);
+	}
+
+	public void enforcedPlatform(String projectPath) {
+		this.configuration.getDependencies().add(getProject().getDependencies().enforcedPlatform(
+				getProject().getDependencies().project(Collections.singletonMap("path", projectPath))));
+		this.projectPaths.add(projectPath);
+	}
+
+	@Internal
+	public Map<String, String> getVersionConstraints() {
+		return Collections.unmodifiableMap(this.versionConstraints);
+	}
+
+	@Internal
+	public Set<ConstrainedVersion> getConstrainedVersions() {
+		return this.constrainedVersions;
+	}
+
+	@Internal
+	public Set<VersionProperty> getVersionProperties() {
+		return this.versionProperties;
+	}
+
+	@TaskAction
+	void extractVersionConstraints() {
+		this.configuration.resolve();
+		for (String projectPath : this.projectPaths) {
+			for (DependencyConstraint constraint : getProject().project(projectPath).getConfigurations()
+					.getByName("apiElements").getAllDependencyConstraints()) {
+				this.versionConstraints.put(constraint.getGroup() + ":" + constraint.getName(),
+						constraint.getVersionConstraint().toString());
+				this.constrainedVersions.add(new ConstrainedVersion(constraint.getGroup(), constraint.getName(),
+						constraint.getVersionConstraint().toString()));
+			}
+		}
+	}
+
+	private void processMetadataDetails(ComponentMetadataDetails details) {
+		details.allVariants((variantMetadata) -> variantMetadata.withDependencyConstraints((dependencyConstraints) -> {
+			for (DependencyConstraintMetadata constraint : dependencyConstraints) {
+				this.versionConstraints.put(constraint.getGroup() + ":" + constraint.getName(),
+						constraint.getVersionConstraint().toString());
+				this.constrainedVersions.add(new ConstrainedVersion(constraint.getGroup(), constraint.getName(),
+						constraint.getVersionConstraint().toString()));
+			}
+		}));
+	}
+
+	public static final class ConstrainedVersion implements Comparable<ConstrainedVersion>, Serializable {
+
+		private final String group;
+
+		private final String artifact;
+
+		private final String version;
+
+		private ConstrainedVersion(String group, String artifact, String version) {
+			this.group = group;
+			this.artifact = artifact;
+			this.version = version;
+		}
+
+		public String getGroup() {
+			return this.group;
+		}
+
+		public String getArtifact() {
+			return this.artifact;
+		}
+
+		public String getVersion() {
+			return this.version;
+		}
+
+		@Override
+		public int compareTo(ConstrainedVersion other) {
+			int groupComparison = this.group.compareTo(other.group);
+			if (groupComparison != 0) {
+				return groupComparison;
+			}
+			return this.artifact.compareTo(other.artifact);
+		}
+
+	}
+
+	public static final class VersionProperty implements Comparable<VersionProperty>, Serializable {
+
+		private final String libraryName;
+
+		private final String versionProperty;
+
+		public VersionProperty(String libraryName, String versionProperty) {
+			this.libraryName = libraryName;
+			this.versionProperty = versionProperty;
+		}
+
+		public String getLibraryName() {
+			return this.libraryName;
+		}
+
+		public String getVersionProperty() {
+			return this.versionProperty;
+		}
+
+		@Override
+		public int compareTo(VersionProperty other) {
+			int groupComparison = this.libraryName.compareToIgnoreCase(other.libraryName);
+			if (groupComparison != 0) {
+				return groupComparison;
+			}
+			return this.versionProperty.compareTo(other.versionProperty);
+		}
+
+	}
+}

buildSrc/src/main/java/org/springframework/statemachine/gradle/JavaConventions.java

@@ -0,0 +1,122 @@
+/*
+ * Copyright 2022 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.statemachine.gradle;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.TreeMap;
+import java.util.stream.Collectors;
+
+import org.gradle.api.JavaVersion;
+import org.gradle.api.Project;
+import org.gradle.api.plugins.JavaBasePlugin;
+import org.gradle.api.tasks.SourceSet;
+import org.gradle.api.tasks.SourceSetContainer;
+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.external.javadoc.CoreJavadocOptions;
+
+/**
+ * @author Janne Valkealahti
+ */
+class JavaConventions {
+
+	private static final String SOURCE_AND_TARGET_COMPATIBILITY = "17";
+
+	void apply(Project project) {
+		project.getPlugins().withType(JavaBasePlugin.class, java -> {
+			configureJavaConventions(project);
+			configureJavadocConventions(project);
+			configureTestConventions(project);
+			configureJarManifestConventions(project);
+		});
+	}
+
+	private void configureJavadocConventions(Project project) {
+		project.getTasks().withType(Javadoc.class, (javadoc) -> {
+			CoreJavadocOptions options = (CoreJavadocOptions) javadoc.getOptions();
+			options.source("17");
+			options.encoding("UTF-8");
+			options.addStringOption("Xdoclint:none", "-quiet");
+		});
+	}
+
+	private void configureJavaConventions(Project project) {
+		project.getTasks().withType(JavaCompile.class, (compile) -> {
+			compile.getOptions().setEncoding("UTF-8");
+			List<String> args = compile.getOptions().getCompilerArgs();
+			if (!args.contains("-parameters")) {
+				args.add("-parameters");
+			}
+			if (project.hasProperty("toolchainVersion")) {
+				compile.setSourceCompatibility(SOURCE_AND_TARGET_COMPATIBILITY);
+				compile.setTargetCompatibility(SOURCE_AND_TARGET_COMPATIBILITY);
+			}
+			else if (buildingWithJava17(project)) {
+				args.addAll(Arrays.asList("-Xdoclint:none"));
+				// TODO: When we're without javadoc errors
+				// args.addAll(Arrays.asList("-Werror", "-Xlint:unchecked", "-Xlint:deprecation", "-Xlint:rawtypes",
+				// 		"-Xlint:varargs"));
+			}
+		});
+	}
+
+	private boolean buildingWithJava17(Project project) {
+		return JavaVersion.current() == JavaVersion.VERSION_17;
+	}
+
+	private void configureTestConventions(Project project) {
+		project.getTasks().withType(Test.class, test -> {
+			test.useJUnitPlatform();
+		});
+	}
+
+	private void configureJarManifestConventions(Project project) {
+		SourceSetContainer sourceSets = project.getExtensions().getByType(SourceSetContainer.class);
+		Set<String> sourceJarTaskNames = sourceSets.stream().map(SourceSet::getSourcesJarTaskName)
+				.collect(Collectors.toSet());
+		Set<String> javadocJarTaskNames = sourceSets.stream().map(SourceSet::getJavadocJarTaskName)
+				.collect(Collectors.toSet());
+
+		project.getTasks().withType(Jar.class, jar -> {
+			jar.manifest(manifest -> {
+				Map<String, Object> attributes = new TreeMap<>();
+				attributes.put("Automatic-Module-Name", project.getName().replace("-", "."));
+				attributes.put("Build-Jdk-Spec", SOURCE_AND_TARGET_COMPATIBILITY);
+				attributes.put("Built-By", "Spring");
+				attributes.put("Implementation-Title",
+						determineImplementationTitle(project, sourceJarTaskNames, javadocJarTaskNames, jar));
+				attributes.put("Implementation-Version", project.getVersion());
+				manifest.attributes(attributes);
+			});
+		});
+	}
+
+	private String determineImplementationTitle(Project project, Set<String> sourceJarTaskNames,
+			Set<String> javadocJarTaskNames, Jar jar) {
+		if (sourceJarTaskNames.contains(jar.getName())) {
+			return "Source for " + project.getName();
+		}
+		if (javadocJarTaskNames.contains(jar.getName())) {
+			return "Javadoc for " + project.getName();
+		}
+		return "Jar for " + project.getName();
+	}
+}

buildSrc/src/main/java/org/springframework/statemachine/gradle/ManagementConfigurationPlugin.java

@@ -0,0 +1,67 @@
+/*
+ * Copyright 2022 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.statemachine.gradle;
+
+import org.gradle.api.Plugin;
+import org.gradle.api.Project;
+import org.gradle.api.artifacts.ConfigurationContainer;
+import org.gradle.api.plugins.JavaPlugin;
+import org.gradle.api.plugins.JavaTestFixturesPlugin;
+import org.gradle.api.plugins.PluginContainer;
+import org.gradle.api.publish.PublishingExtension;
+import org.gradle.api.publish.maven.MavenPublication;
+import org.gradle.api.publish.maven.plugins.MavenPublishPlugin;
+
+/**
+ * Creates a Management configuration that is appropriate for adding a platform
+ * to that is not exposed externally. If the JavaPlugin is applied, the
+ * compileClasspath, runtimeClasspath, testCompileClasspath, and
+ * testRuntimeClasspath will extend from it.
+ *
+ * @author Janne Valkealahti
+ */
+public class ManagementConfigurationPlugin implements Plugin<Project> {
+
+	public static final String MANAGEMENT_CONFIGURATION_NAME = "management";
+
+	@Override
+	public void apply(Project project) {
+		ConfigurationContainer configurations = project.getConfigurations();
+		configurations.create(MANAGEMENT_CONFIGURATION_NAME, (management) -> {
+			management.setVisible(false);
+			management.setCanBeConsumed(false);
+			management.setCanBeResolved(false);
+			PluginContainer plugins = project.getPlugins();
+			plugins.withType(JavaPlugin.class, (javaPlugin) -> {
+				configurations.getByName(JavaPlugin.IMPLEMENTATION_CONFIGURATION_NAME).extendsFrom(management);
+			});
+			plugins.withType(JavaTestFixturesPlugin.class, (javaTestFixturesPlugin) -> {
+				configurations.getByName("testFixturesCompileClasspath").extendsFrom(management);
+				configurations.getByName("testFixturesRuntimeClasspath").extendsFrom(management);
+			});
+			plugins.withType(OptionalDependenciesPlugin.class, (optionalDependencies) -> configurations
+				.getByName(OptionalDependenciesPlugin.OPTIONAL_CONFIGURATION_NAME).extendsFrom(management));
+			plugins.withType(MavenPublishPlugin.class, (mavenPublish) -> {
+				PublishingExtension publishing = project.getExtensions().getByType(PublishingExtension.class);
+				publishing.getPublications().withType(MavenPublication.class, (mavenPublication -> {
+					mavenPublication.versionMapping((versions) ->
+							versions.allVariants(versionMapping -> versionMapping.fromResolutionResult())
+					);
+				}));
+			});
+		});
+	}
+}

buildSrc/src/main/java/org/springframework/statemachine/gradle/ModulePlugin.java

@@ -0,0 +1,43 @@
+/*
+ * Copyright 2022 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.statemachine.gradle;
+
+import org.gradle.api.Plugin;
+import org.gradle.api.Project;
+import org.gradle.api.plugins.JavaLibraryPlugin;
+import org.gradle.api.plugins.JavaPlugin;
+import org.gradle.api.plugins.JavaTestFixturesPlugin;
+import org.gradle.api.plugins.PluginManager;
+
+/**
+ * @author Janne Valkealahti
+ */
+class ModulePlugin implements Plugin<Project> {
+
+	@Override
+	public final void apply(Project project) {
+		PluginManager pluginManager = project.getPluginManager();
+		pluginManager.apply(JavaPlugin.class);
+		pluginManager.apply(OptionalDependenciesPlugin.class);
+		pluginManager.apply(ManagementConfigurationPlugin.class);
+		pluginManager.apply(JavaLibraryPlugin.class);
+		pluginManager.apply(SpringMavenPlugin.class);
+		pluginManager.apply(JavaTestFixturesPlugin.class);
+		new ArtifactoryConventions().apply(project);
+		new JavaConventions().apply(project);
+		new EclipseConventions().apply(project);
+	}
+}

buildSrc/src/main/java/org/springframework/statemachine/gradle/OptionalDependenciesPlugin.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2023 the original author or authors.
+ * Copyright 2022 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -22,26 +22,13 @@ import org.gradle.api.plugins.JavaPlugin;
 import org.gradle.api.plugins.JavaPluginExtension;
 import org.gradle.api.tasks.SourceSetContainer;
 
-/**
- * A {@code Plugin} that adds support for Maven-style optional dependencies.
- * Creates a new
- * {@code optional} configuration. The {@code optional} configuration is part of
- * the
- * project's compile and runtime classpaths but does not affect the classpath of
- * dependent projects.
- *
- * @author Janne Valkealahti
- */
 public class OptionalDependenciesPlugin implements Plugin<Project> {
 
-	/**
-	 * Name of the {@code optional} configuration.
-	 */
 	public static final String OPTIONAL_CONFIGURATION_NAME = "optional";
 
 	@Override
 	public void apply(Project project) {
-		Configuration optional = project.getConfigurations().create("optional");
+		Configuration optional = project.getConfigurations().create(OPTIONAL_CONFIGURATION_NAME);
 		optional.setCanBeConsumed(false);
 		optional.setCanBeResolved(false);
 		project.getPlugins().withType(JavaPlugin.class, (javaPlugin) -> {
@@ -55,5 +42,4 @@ public class OptionalDependenciesPlugin implements Plugin<Project> {
 			});
 		});
 	}
-
 }

buildSrc/src/main/java/org/springframework/statemachine/gradle/PublishAllJavaComponentsPlugin.java

@@ -0,0 +1,46 @@
+/*
+ * Copyright 2022 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.statemachine.gradle;
+
+import org.gradle.api.Action;
+import org.gradle.api.Plugin;
+import org.gradle.api.Project;
+import org.gradle.api.plugins.JavaPlatformPlugin;
+import org.gradle.api.plugins.JavaPlugin;
+import org.gradle.api.publish.PublishingExtension;
+import org.gradle.api.publish.maven.MavenPublication;
+import org.gradle.api.publish.maven.plugins.MavenPublishPlugin;
+
+public class PublishAllJavaComponentsPlugin implements Plugin<Project> {
+
+	@Override
+	public void apply(Project project) {
+		project.getPlugins().withType(MavenPublishPlugin.class).all((mavenPublish) -> {
+			PublishingExtension publishing = project.getExtensions().getByType(PublishingExtension.class);
+			publishing.getPublications().create("mavenJava", MavenPublication.class, new Action<MavenPublication>() {
+				@Override
+				public void execute(MavenPublication maven) {
+					project.getPlugins().withType(JavaPlugin.class, (plugin) -> {
+							maven.from(project.getComponents().getByName("java"));
+					});
+					project.getPlugins().withType(JavaPlatformPlugin.class, (plugin) -> {
+							maven.from(project.getComponents().getByName("javaPlatform"));
+					});
+				}
+			});
+		});
+	}
+}

buildSrc/src/main/java/org/springframework/statemachine/gradle/PublishLocalPlugin.java

@@ -0,0 +1,37 @@
+/*
+ * Copyright 2022 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.statemachine.gradle;
+
+import java.io.File;
+
+import org.gradle.api.Plugin;
+import org.gradle.api.Project;
+import org.gradle.api.publish.PublishingExtension;
+import org.gradle.api.publish.maven.plugins.MavenPublishPlugin;
+
+public class PublishLocalPlugin implements Plugin<Project> {
+
+	@Override
+	public void apply(Project project) {
+
+		project.getPlugins().withType(MavenPublishPlugin.class).all(mavenPublish -> {
+			project.getExtensions().getByType(PublishingExtension.class).getRepositories().maven(maven -> {
+				maven.setName("local");
+				maven.setUrl(new File(project.getRootProject().getBuildDir(), "publications/repos"));
+			});
+		});
+	}
+}

buildSrc/src/main/java/org/springframework/statemachine/gradle/RootPlugin.java

@@ -0,0 +1,97 @@
+/*
+ * Copyright 2022 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.statemachine.gradle;
+
+import java.io.File;
+
+import org.asciidoctor.gradle.jvm.AsciidoctorJPlugin;
+import org.gradle.api.Plugin;
+import org.gradle.api.Project;
+import org.gradle.api.plugins.JavaPluginConvention;
+import org.gradle.api.plugins.PluginManager;
+import org.gradle.api.publish.maven.plugins.MavenPublishPlugin;
+import org.gradle.api.tasks.SourceSet;
+import org.gradle.api.tasks.bundling.Zip;
+import org.gradle.api.tasks.javadoc.Javadoc;
+import org.gradle.external.javadoc.CoreJavadocOptions;
+
+/**
+ * Manages tasks creating zip file for docs and publishing it.
+ *
+ * @author Janne Valkealahti
+ */
+class RootPlugin implements Plugin<Project> {
+
+	@Override
+	public void apply(Project project) {
+		PluginManager pluginManager = project.getPluginManager();
+		pluginManager.apply(MavenPublishPlugin.class);
+		pluginManager.apply(PublishLocalPlugin.class);
+		new ArtifactoryConventions().apply(project);
+		Javadoc apiTask = createApiTask(project);
+		Zip zipTask = createZipTask(project);
+		zipTask.dependsOn(apiTask);
+	}
+
+	private Zip createZipTask(Project project) {
+		Zip zipTask = project.getTasks().create("distZip", Zip.class, zip -> {
+			zip.setGroup("Distribution");
+			zip.from("docs/build/docs/asciidoc/", copy -> {
+				copy.into("docs");
+			});
+			zip.from("build/api", copy -> {
+				copy.into("api");
+			});
+		});
+
+		project.getRootProject().getAllprojects().forEach(p -> {
+			p.getPlugins().withType(AsciidoctorJPlugin.class, a -> {
+				p.getTasksByName("asciidoctor", false).forEach(t -> {
+					zipTask.dependsOn(t);
+				});;
+			});
+		});
+
+		project.getArtifacts().add("archives", zipTask);
+		return zipTask;
+	}
+
+	private Javadoc createApiTask(Project project) {
+		Javadoc api = project.getTasks().create("api", Javadoc.class, a -> {
+			a.setGroup("Documentation");
+			a.setDescription("Generates aggregated Javadoc API documentation.");
+			a.setDestinationDir(new File(project.getBuildDir(), "api"));
+			CoreJavadocOptions options = (CoreJavadocOptions) a.getOptions();
+			options.source("17");
+			options.encoding("UTF-8");
+			options.addStringOption("Xdoclint:none", "-quiet");
+		});
+
+		project.getRootProject().getSubprojects().forEach(p -> {
+			p.getPlugins().withType(ModulePlugin.class, m -> {
+				JavaPluginConvention java = p.getConvention().getPlugin(JavaPluginConvention.class);
+				SourceSet mainSourceSet = java.getSourceSets().getByName("main");
+
+				api.setSource(api.getSource().plus(mainSourceSet.getAllJava()));
+
+				p.getTasks().withType(Javadoc.class, j -> {
+					api.setClasspath(api.getClasspath().plus(j.getClasspath()));
+				});
+			});
+		});
+		return api;
+	}
+}

buildSrc/src/main/java/org/springframework/statemachine/gradle/SamplePlugin.java

@@ -0,0 +1,36 @@
+/*
+ * Copyright 2022 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.statemachine.gradle;
+
+import org.gradle.api.Plugin;
+import org.gradle.api.Project;
+import org.gradle.api.plugins.JavaPlugin;
+import org.gradle.api.plugins.PluginManager;
+
+/**
+ * @author Janne Valkealahti
+ */
+class SamplePlugin implements Plugin<Project> {
+
+	@Override
+	public void apply(Project project) {
+		PluginManager pluginManager = project.getPluginManager();
+		pluginManager.apply(JavaPlugin.class);
+		pluginManager.apply(ManagementConfigurationPlugin.class);
+		new JavaConventions().apply(project);
+		new EclipseConventions().apply(project);
+	}
+}

buildSrc/src/main/java/org/springframework/statemachine/gradle/SpringMavenPlugin.java

@@ -0,0 +1,158 @@
+/*
+ * Copyright 2022 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.statemachine.gradle;
+
+import java.util.List;
+import java.util.ListIterator;
+
+import org.gradle.api.Plugin;
+import org.gradle.api.Project;
+import org.gradle.api.attributes.Usage;
+import org.gradle.api.component.AdhocComponentWithVariants;
+import org.gradle.api.component.ConfigurationVariantDetails;
+import org.gradle.api.plugins.JavaPlugin;
+import org.gradle.api.plugins.JavaPluginExtension;
+import org.gradle.api.plugins.PluginManager;
+import org.gradle.api.publish.PublishingExtension;
+import org.gradle.api.publish.VariantVersionMappingStrategy;
+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 groovy.util.Node;
+
+public class SpringMavenPlugin implements Plugin<Project> {
+
+	@Override
+	public void apply(Project project) {
+		PluginManager pluginManager = project.getPluginManager();
+		pluginManager.apply(MavenPublishPlugin.class);
+		pluginManager.apply(SpringSigningPlugin.class);
+		pluginManager.apply(PublishLocalPlugin.class);
+		pluginManager.apply(PublishAllJavaComponentsPlugin.class);
+
+		project.getPlugins().withType(MavenPublishPlugin.class).all(mavenPublish -> {
+			PublishingExtension publishing = project.getExtensions().getByType(PublishingExtension.class);
+			publishing.getPublications().withType(MavenPublication.class)
+				.all(mavenPublication -> customizeMavenPublication(mavenPublication, project));
+			project.getPlugins().withType(JavaPlugin.class).all(javaPlugin -> {
+				JavaPluginExtension extension = project.getExtensions().getByType(JavaPluginExtension.class);
+				extension.withJavadocJar();
+				extension.withSourcesJar();
+			});
+		});
+	}
+
+	private void customizeMavenPublication(MavenPublication publication, Project project) {
+		customizePom(publication.getPom(), project);
+		project.getPlugins().withType(JavaPlugin.class)
+				.all((javaPlugin) -> customizeJavaMavenPublication(publication, project));
+		suppressMavenOptionalFeatureWarnings(publication);
+	}
+
+	private void customizeJavaMavenPublication(MavenPublication publication, Project project) {
+		addMavenOptionalFeature(project);
+		publication.versionMapping((strategy) -> strategy.usage(Usage.JAVA_API, (mappingStrategy) -> mappingStrategy
+				.fromResolutionOf(JavaPlugin.RUNTIME_CLASSPATH_CONFIGURATION_NAME)));
+		publication.versionMapping(
+				(strategy) -> strategy.usage(Usage.JAVA_RUNTIME, VariantVersionMappingStrategy::fromResolutionResult));
+	}
+
+	private void suppressMavenOptionalFeatureWarnings(MavenPublication publication) {
+		publication.suppressPomMetadataWarningsFor("mavenOptionalApiElements");
+		publication.suppressPomMetadataWarningsFor("mavenOptionalRuntimeElements");
+	}
+
+	private void addMavenOptionalFeature(Project project) {
+		JavaPluginExtension extension = project.getExtensions().getByType(JavaPluginExtension.class);
+		extension.registerFeature("mavenOptional",
+				(feature) -> feature.usingSourceSet(extension.getSourceSets().getByName("main")));
+		AdhocComponentWithVariants javaComponent = (AdhocComponentWithVariants) project.getComponents()
+				.findByName("java");
+		if (javaComponent != null) {
+			javaComponent.addVariantsFromConfiguration(
+				project.getConfigurations().findByName("mavenOptionalRuntimeElements"),
+				ConfigurationVariantDetails::mapToOptional);
+		}
+	}
+
+	private void customizePom(MavenPom pom, Project project) {
+		pom.getUrl().set("https://spring.io/projects/spring-statemachine");
+		pom.getName().set(project.provider(project::getName));
+		pom.getDescription().set(project.provider(project::getDescription));
+		pom.organization(this::customizeOrganization);
+		pom.licenses(this::customizeLicences);
+		pom.developers(this::customizeDevelopers);
+		pom.scm(scm -> customizeScm(scm, project));
+		pom.issueManagement(this::customizeIssueManagement);
+
+		// TODO: find something better not to add dependencyManagement in pom
+		//       which result spring-statemachine-platform in it. spring-statemachine-bom
+		//       has its own dependencyManagement which we need to keep
+		if (!project.getName().equals("spring-statemachine-bom")) {
+			pom.withXml(xxx -> {
+				Node pomNode = xxx.asNode();
+				List<?> childs = pomNode.children();
+				ListIterator<?> iter = childs.listIterator();
+				while (iter.hasNext()) {
+					Object next = iter.next();
+					if (next instanceof Node) {
+						if (((Node)next).name().toString().equals("{http://maven.apache.org/POM/4.0.0}dependencyManagement")) {
+							iter.remove();
+						}
+					}
+				}
+			});
+		}
+	}
+
+	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("https://www.apache.org/licenses/LICENSE-2.0");
+		});
+	}
+
+	private void customizeDevelopers(MavenPomDeveloperSpec developers) {
+		developers.developer((developer) -> {
+			developer.getName().set("Pivotal");
+			developer.getEmail().set("info@pivotal.io");
+			developer.getOrganization().set("Pivotal Software, Inc.");
+			developer.getOrganizationUrl().set("https://www.spring.io");
+		});
+	}
+
+	private void customizeScm(MavenPomScm scm, Project project) {
+		scm.getConnection().set("scm:git:git://github.com/spring-projects/spring-statemachine.git");
+		scm.getDeveloperConnection().set("scm:git:ssh://git@github.com/spring-projects/spring-statemachine.git");
+		scm.getUrl().set("https://github.com/spring-projects/spring-statemachine");
+	}
+
+	private void customizeIssueManagement(MavenPomIssueManagement issueManagement) {
+		issueManagement.getSystem().set("GitHub");
+		issueManagement.getUrl().set("https://github.com/spring-projects/spring-statemachine/issues");
+	}
+}

buildSrc/src/main/java/org/springframework/statemachine/gradle/SpringSigningPlugin.java

@@ -0,0 +1,70 @@
+/*
+ * Copyright 2016-2019 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+
+ package org.springframework.statemachine.gradle;
+
+import java.util.concurrent.Callable;
+
+import org.gradle.api.Action;
+import org.gradle.api.Plugin;
+import org.gradle.api.Project;
+import org.gradle.api.publish.Publication;
+import org.gradle.api.publish.PublishingExtension;
+import org.gradle.plugins.signing.SigningExtension;
+import org.gradle.plugins.signing.SigningPlugin;
+
+public class SpringSigningPlugin implements Plugin<Project> {
+	@Override
+	public void apply(Project project) {
+		project.getPluginManager().apply(SigningPlugin.class);
+		project.getPlugins().withType(SigningPlugin.class).all(new Action<SigningPlugin>() {
+			@Override
+			public void execute(SigningPlugin signingPlugin) {
+				boolean hasSigningKey = project.hasProperty("signingKey");
+				if (hasSigningKey) {
+					sign(project);
+				}
+			}
+		});
+	}
+
+	private void sign(Project project) {
+		SigningExtension signing = project.getExtensions().findByType(SigningExtension.class);
+		signing.setRequired(new Callable<Boolean>() {
+			@Override
+			public Boolean call() throws Exception {
+				return project.getGradle().getTaskGraph().hasTask("publishArtifacts");
+			}
+		});
+		String signingKeyId = (String) project.findProperty("signingKeyId");
+		String signingKey = (String) project.findProperty("signingKey");
+		String signingPassword = (String) project.findProperty("signingPassword");
+		if (signingKeyId != null) {
+			signing.useInMemoryPgpKeys(signingKeyId, signingKey, signingPassword);
+		} else {
+			signing.useInMemoryPgpKeys(signingKey, signingPassword);
+		}
+		project.getPlugins().withType(PublishAllJavaComponentsPlugin.class)
+				.all(new Action<PublishAllJavaComponentsPlugin>() {
+					@Override
+					public void execute(PublishAllJavaComponentsPlugin publishingPlugin) {
+						PublishingExtension publishing = project.getExtensions().findByType(PublishingExtension.class);
+						Publication maven = publishing.getPublications().getByName("mavenJava");
+						signing.sign(maven);
+					}
+				});
+	}
+}

buildSrc/src/main/java/org/springframework/statemachine/gradle/StarterPlugin.java

@@ -0,0 +1,40 @@
+/*
+ * Copyright 2022 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.statemachine.gradle;
+
+import org.gradle.api.Plugin;
+import org.gradle.api.Project;
+import org.gradle.api.plugins.JavaLibraryPlugin;
+import org.gradle.api.plugins.PluginContainer;
+import org.gradle.api.plugins.PluginManager;
+
+/**
+ * @author Janne Valkealahti
+ */
+class StarterPlugin implements Plugin<Project> {
+
+	@Override
+	public void apply(Project project) {
+		PluginManager pluginManager = project.getPluginManager();
+		pluginManager.apply(ManagementConfigurationPlugin.class);
+		PluginContainer plugins = project.getPlugins();
+		plugins.apply(JavaLibraryPlugin.class);
+		pluginManager.apply(SpringMavenPlugin.class);
+
+		new ArtifactoryConventions().apply(project);
+		new JavaConventions().apply(project);
+	}
+}