Merge branch '4.0.x' into 4.1.x

Closes gh-1595

Author: snicoll

gradle.properties

@@ -3,5 +3,7 @@ version=4.1.1-SNAPSHOT
 org.gradle.caching=true
 org.gradle.parallel=true
 
+versionUpgradePolicy=same_minor_version
+
 compatibilityTestPluginVersion=0.0.3
 springFrameworkVersion=6.2.7

gradle/plugins/conventions-plugin/build.gradle

@@ -5,12 +5,18 @@ plugins {
 }
 
 repositories {
+	gradlePluginPortal()
 	mavenCentral()
 }
 
 dependencies {
+	api(platform("org.junit:junit-bom:${junitVersion}"))
 	checkstyle("com.puppycrawl.tools:checkstyle:${checkstyle.toolVersion}")
 	checkstyle("io.spring.javaformat:spring-javaformat-checkstyle:${javaFormatVersion}")
+
+	testImplementation("org.junit.jupiter:junit-jupiter")
+	testImplementation("org.assertj:assertj-core:${assertJVersion}")
+	testRuntimeOnly("org.junit.platform:junit-platform-launcher")
 }
 
 gradlePlugin {
@@ -23,5 +29,10 @@ gradlePlugin {
 }
 
 dependencies {
+	implementation("com.github.ben-manes:gradle-versions-plugin:$gradleVersionsPluginVersion")
 	implementation("io.spring.javaformat:spring-javaformat-gradle-plugin:$javaFormatVersion")
 }
+
+tasks.named('test') {
+	useJUnitPlatform()
+}

gradle/plugins/conventions-plugin/src/main/java/org/springframework/ws/gradle/conventions/JavaPluginConventions.java

@@ -51,6 +51,7 @@ void apply(Project project) {
 		enableSourceAndJavadocJars(java);
 		configureSourceAndTargetCompatibility(java);
 		configureDependencyManagement(project);
+		configureVersionUpgradePolicy(project);
 		configureJarManifest(project);
 		configureToolchain(project, java);
 		configureJavadocClasspath(project, java);
@@ -98,6 +99,10 @@ private void configureDependencyManagement(Project project) {
 			.add(dependencies.enforcedPlatform(dependencies.project(Map.of("path", ":spring-ws-platform"))));
 	}
 
+	private void configureVersionUpgradePolicy(Project project) {
+		new VersionUpgradePluginConventions().apply(project);
+	}
+
 	private void configureJarManifest(Project project) {
 		project.getTasks().named("jar", Jar.class, (jar) -> jar.manifest((manifest) -> {
 			Map<String, Object> attributes = new TreeMap<>();

gradle/plugins/conventions-plugin/src/main/java/org/springframework/ws/gradle/conventions/VersionUpgradePluginConventions.java

@@ -0,0 +1,60 @@
+/*
+ * Copyright 2005-2025 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.ws.gradle.conventions;
+
+import java.util.Locale;
+
+import com.github.benmanes.gradle.versions.VersionsPlugin;
+import com.github.benmanes.gradle.versions.updates.DependencyUpdatesTask;
+import org.gradle.api.Project;
+
+import org.springframework.ws.gradle.conventions.support.Version;
+import org.springframework.ws.gradle.conventions.support.VersionUpgradePolicy;
+
+/**
+ * Conventions for {@code gradle-versions-plugin}.
+ *
+ * @author Stephane Nicoll
+ */
+class VersionUpgradePluginConventions {
+
+	void apply(Project project) {
+		project.getPlugins().apply(VersionsPlugin.class);
+		project.getTasks().withType(DependencyUpdatesTask.class, (updateTask) -> {
+			updateTask.setFilterConfigurations((configuration) -> !(configuration.getName().contains("_")
+					&& configuration.getName().endsWith("+")));
+			VersionUpgradePolicy upgradePolicy = getUpgradePolicy(project);
+			updateTask.rejectVersionIf((candidate) -> {
+				Version currentVersion = Version.from(candidate.getCurrentVersion());
+				Version candidateVersion = Version.from(candidate.getCandidate().getVersion());
+				return !upgradePolicy.isCandidate(currentVersion, candidateVersion);
+			});
+		});
+	}
+
+	private VersionUpgradePolicy getUpgradePolicy(Project project) {
+		Object versionUpgradePolicy = project.findProperty("versionUpgradePolicy");
+		if (versionUpgradePolicy == null) {
+			return VersionUpgradePolicy.SAME_MINOR_VERSION;
+		}
+		else if (versionUpgradePolicy instanceof String value) {
+			return VersionUpgradePolicy.valueOf(value.toUpperCase(Locale.ROOT));
+		}
+		throw new IllegalArgumentException("Unsupported version upgrade policy: " + versionUpgradePolicy);
+	}
+
+}

gradle/plugins/conventions-plugin/src/main/java/org/springframework/ws/gradle/conventions/support/Version.java

@@ -0,0 +1,171 @@
+/*
+ * Copyright 2012-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.ws.gradle.conventions.support;
+
+import java.io.Serializable;
+import java.util.Objects;
+
+/**
+ * ë A version representation that provides a major and minor identifier. For instance,
+ * {@code 1.2.5} would have a {@code major} of "1" and {@code minor} of "1.2".
+ *
+ * @author Stephane Nicoll
+ */
+public class Version {
+
+	private final String id;
+
+	private final String major;
+
+	private final String minor;
+
+	private final Qualifier qualifier;
+
+	private final Parts parts;
+
+	Version(String id, String major, String minor, Qualifier qualifer, Parts parts) {
+		this.id = id;
+		this.major = major;
+		this.minor = minor;
+		this.qualifier = qualifer;
+		this.parts = parts;
+	}
+
+	public static Version from(String version) {
+		return VersionParser.safeParse(version);
+	}
+
+	/**
+	 * Return the version.
+	 * @return the version
+	 */
+	public String getId() {
+		return this.id;
+	}
+
+	/**
+	 * Return the major qualifier or {@code null}.
+	 * @return the major
+	 */
+	public String getMajor() {
+		return this.major;
+	}
+
+	/**
+	 * Return the minor qualifier or {@code null}.
+	 * @return the minor
+	 */
+	public String getMinor() {
+		return this.minor;
+	}
+
+	/**
+	 * Return tue {@link Qualifier} or {@code null}.
+	 * @return the qualifier
+	 */
+	public Qualifier getQualifier() {
+		return this.qualifier;
+	}
+
+	/**
+	 * Return the elements of the version, if any. Does not apply for non-numeric version
+	 * such as a release train.
+	 * @return the parts
+	 */
+	public Parts getParts() {
+		return this.parts;
+	}
+
+	/**
+	 * Returns whether this version has the same major and minor versions as the
+	 * {@code other} version.
+	 * @param other the version to test
+	 * @return {@code true} if this version has the same major and minor, otherwise
+	 * {@code false}
+	 */
+	public boolean isSameMinor(Version other) {
+		return isSameMajor(other) && Objects.equals(this.parts.minor, other.parts.minor);
+	}
+
+	/**
+	 * Returns whether this version has the same major version as the {@code other}
+	 * version.
+	 * @param other the version to test
+	 * @return {@code true} if this version has the same major, otherwise {@code false}
+	 */
+	public boolean isSameMajor(Version other) {
+		return (this.parts != null && other.parts != null && Objects.equals(this.parts.major, other.parts.major));
+	}
+
+	@Override
+	public boolean equals(Object o) {
+		if (this == o) {
+			return true;
+		}
+		if (!(o instanceof Version version)) {
+			return false;
+		}
+		return Objects.equals(this.id, version.id);
+	}
+
+	@Override
+	public int hashCode() {
+		return Objects.hashCode(this.id);
+	}
+
+	@Override
+	public String toString() {
+		return this.id;
+	}
+
+	public record Parts(Integer major, Integer minor, Integer patch, Integer hotPatch) {
+
+		/**
+		 * Return a unique number for this instance that allows to compare two versions.
+		 * @return a comparable number
+		 */
+		public long toNumber() {
+			String paddedValue = paddedNumber(this.major) + paddedNumber(this.minor) + paddedNumber(this.patch)
+					+ paddedNumber(this.hotPatch);
+			return Long.parseLong(paddedValue);
+		}
+
+		private String paddedNumber(Integer number) {
+			if (number != null) {
+				return String.format("%02d", number);
+			}
+			return "00";
+		}
+
+	}
+
+	/**
+	 * A version qualifier.
+	 *
+	 * @param id the identifier of the qualifier
+	 * @param version the version or {@code null}
+	 * @param separator the separator
+	 */
+	public record Qualifier(String id, Integer version, String separator) implements Serializable {
+
+		public Qualifier(String id) {
+			this(id, null, ".");
+		}
+
+	}
+
+}