Use fully-resolved properties/config to determine build metadata

src/main/java/org/hibernate/search/develocity/GoalMetadataProvider.java

@@ -0,0 +1,55 @@
+/*
+ *
+ *  * Hibernate Search, full-text search for your domain model
+ *  *
+ *  * License: GNU Lesser General Public License (LGPL), version 2.1 or later
+ *  * See the lgpl.txt file in the root directory or <http://www.gnu.org/licenses/lgpl-2.1.html>.
+ *
+ */
+package org.hibernate.search.develocity;
+
+import org.hibernate.search.develocity.util.MavenMojoExecutionConfig;
+import org.hibernate.search.develocity.util.MavenProperties;
+
+import com.gradle.maven.extension.api.cache.MojoMetadataProvider;
+import com.gradle.maven.extension.api.scan.BuildScanApi;
+
+@FunctionalInterface
+public interface GoalMetadataProvider {
+	void configure(Context context);
+
+	class Context {
+		private final BuildScanApi buildScanApi;
+		private final MojoMetadataProvider.Context metadataContext;
+		private final MavenProperties properties;
+		private final MavenMojoExecutionConfig configuration;
+
+
+		public Context(BuildScanApi buildScanApi, MojoMetadataProvider.Context metadataContext) {
+			this.buildScanApi = buildScanApi;
+			this.metadataContext = metadataContext;
+			this.properties = new MavenProperties( metadataContext.getSession(), metadataContext.getMojoExecution() );
+			this.configuration = new MavenMojoExecutionConfig( metadataContext.getMojoExecution() );
+		}
+
+		public BuildScanApi buildScan() {
+			return buildScanApi;
+		}
+
+		public MojoMetadataProvider.Context metadata() {
+			return metadataContext;
+		}
+
+		public MavenProperties properties() {
+			return properties;
+		}
+
+		public MavenMojoExecutionConfig configuration() {
+			return configuration;
+		}
+
+		public void buildScanDeduplicatedValue(String key, String value) {
+			buildScanApi.executeOnce( key + value, ignored -> buildScanApi.value( key, value ) );
+		}
+	}
+}

src/main/java/org/hibernate/search/develocity/HibernateSearchProjectDevelocityListener.java

@@ -26,10 +26,11 @@ public class HibernateSearchProjectDevelocityListener implements GradleEnterpris
 
 
     @Override
-    public void configure(GradleEnterpriseApi gradleEnterpriseApi, MavenSession mavenSession) throws Exception {
+    public void configure(GradleEnterpriseApi gradleEnterpriseApi, MavenSession mavenSession) {
         gradleEnterpriseApi.getBuildScan().publishAlways();
         ((BuildScanApiInternal) gradleEnterpriseApi.getBuildScan()).publishIfAuthenticated();
-        BuildScanMetadata.addMetadataToBuildScan(gradleEnterpriseApi.getBuildScan(), mavenSession);
+
+        BuildScanMetadata.addMainMetadata(gradleEnterpriseApi.getBuildScan());
 
         Normalization.configureNormalization(gradleEnterpriseApi.getBuildCache());
 

src/main/java/org/hibernate/search/develocity/SimpleConfiguredPlugin.java

@@ -5,13 +5,11 @@
 import java.util.Map.Entry;
 import java.util.function.Function;
 
+import org.hibernate.search.develocity.scan.BuildScanMetadata;
 import org.hibernate.search.develocity.util.JavaVersions;
-import org.hibernate.search.develocity.util.MavenConfigs;
 
 import com.gradle.maven.extension.api.GradleEnterpriseApi;
 import com.gradle.maven.extension.api.cache.MojoMetadataProvider;
-import com.gradle.maven.extension.api.cache.NormalizationProvider;
-import com.gradle.maven.extension.api.scan.BuildScanApi;
 import org.apache.maven.execution.MavenSession;
 import org.apache.maven.project.MavenProject;
 
@@ -27,16 +25,17 @@ public void configureBuildCache(GradleEnterpriseApi gradleEnterpriseApi, MavenSe
                     return;
                 }
 
-                Map<String, GoalMetadataProvider> goalMetadataProviders = Collections.unmodifiableMap(getGoalMetadataProviders(gradleEnterpriseApi.getBuildScan()));
+                Map<String, GoalMetadataProvider> goalMetadataProviders = Collections.unmodifiableMap(getGoalMetadataProviders());
 
                 Log.debug(getPluginName(), "Build cache is enabled. Configuring metadata providers.");
                 Log.debug(getPluginName(), "Configuring metadata for goals: " + goalMetadataProviders.keySet());
 
-                for (Entry<String, GoalMetadataProvider> goalMetadataProviderEntry : goalMetadataProviders.entrySet()) {
-                    if (goalMetadataProviderEntry.getKey().equalsIgnoreCase(context.getMojoExecution().getGoal())) {
-                        goalMetadataProviderEntry.getValue().configure(context);
-                    }
-                }
+				for ( Entry<String, GoalMetadataProvider> goalMetadataProviderEntry : goalMetadataProviders.entrySet() ) {
+					if ( goalMetadataProviderEntry.getKey().equalsIgnoreCase( context.getMojoExecution().getGoal() ) ) {
+						goalMetadataProviderEntry.getValue()
+								.configure( new GoalMetadataProvider.Context( gradleEnterpriseApi.getBuildScan(), context ) );
+					}
+				}
             });
         });
     }
@@ -47,10 +46,11 @@ protected boolean isBuildCacheEnabled(MavenProject project) {
         return true;
     }
 
-    protected abstract Map<String, GoalMetadataProvider> getGoalMetadataProviders(BuildScanApi buildScanApi);
+    protected abstract Map<String, GoalMetadataProvider> getGoalMetadataProviders();
 
-    protected static void dependsOnGav(MojoMetadataProvider.Context.Inputs inputs, MojoMetadataProvider.Context context) {
-        inputs.property("_internal_gav", context.getProject().getGroupId() + ":" + context.getProject().getArtifactId() + ":" + context.getProject().getVersion());
+    protected static void dependsOnGav(MojoMetadataProvider.Context.Inputs inputs, GoalMetadataProvider.Context context) {
+		var project = context.metadata().getProject();
+        inputs.property("_internal_gav", project.getGroupId() + ":" + project.getArtifactId() + ":" + project.getVersion());
     }
 
 
@@ -65,31 +65,24 @@ protected static void dependsOnMavenJavaVersion(MojoMetadataProvider.Context.Inp
     }
 
     protected static void dependsOnConfigurableJavaExecutable(MojoMetadataProvider.Context.Inputs inputs,
-            MojoMetadataProvider.Context context, String configChildName,
+			GoalMetadataProvider.Context context, String configChildName, Boolean skipped,
             Function<String, String> executableToVersion) {
-        var configChild = context.getMojoExecution().getConfiguration().getChild( configChildName );
-        String javaExecutable = configChild == null ? null : configChild.getValue();
+		String javaExecutable = context.configuration().getString( configChildName );
 		String javaVersion = executableToVersion.apply( javaExecutable );
+		boolean canCacheExactVersion = context.properties().cacheExactJavaVersion();
 		inputs.property( "_internal_" + configChildName + "_java_version",
-				MavenConfigs.cacheExactJavaVersion( context.getSession() )
+				canCacheExactVersion
 						? javaVersion
 						: JavaVersions.toJdkMajor( javaVersion, javaVersion ) );
-		Log.info(
-                context.getMojoExecution().getPlugin().getArtifactId(),
-				"Using %s at path '%s'; resolved version: %s"
-						.formatted( configChildName, javaExecutable, javaVersion.replace( '\n', ' ' ).trim() )
-        );
-    }
-
-    @FunctionalInterface
-    public interface PluginNormalizationProvider {
 
-        void configure(NormalizationProvider.Context context);
+		if ( skipped == null || !skipped ) {
+			BuildScanMetadata.addJavaExecutableVersion( context, javaExecutable, javaVersion, canCacheExactVersion );
+			Log.info(
+					context.metadata().getMojoExecution().getPlugin().getArtifactId(),
+					"Using %s at path '%s'; resolved version: %s"
+							.formatted( configChildName, javaExecutable, javaVersion.replace( '\n', ' ' ).trim() )
+			);
+		}
     }
 
-    @FunctionalInterface
-    public interface GoalMetadataProvider {
-
-        void configure(MojoMetadataProvider.Context context);
-    }
 }

src/main/java/org/hibernate/search/develocity/plugins/CompilerConfiguredPlugin.java

@@ -2,12 +2,10 @@
 
 import java.util.Map;
 
+import org.hibernate.search.develocity.GoalMetadataProvider;
 import org.hibernate.search.develocity.SimpleConfiguredPlugin;
 import org.hibernate.search.develocity.util.JavaVersions;
 
-import com.gradle.maven.extension.api.cache.MojoMetadataProvider;
-import com.gradle.maven.extension.api.scan.BuildScanApi;
-
 public class CompilerConfiguredPlugin extends SimpleConfiguredPlugin {
 
 	@Override
@@ -16,16 +14,19 @@ protected String getPluginName() {
 	}
 
 	@Override
-	protected Map<String, GoalMetadataProvider> getGoalMetadataProviders(BuildScanApi buildScanApi) {
+	protected Map<String, GoalMetadataProvider> getGoalMetadataProviders() {
 		return Map.of(
 				"compile", CompilerConfiguredPlugin::configureCompile,
 				"testCompile", CompilerConfiguredPlugin::configureCompile
 		);
 	}
 
-	private static void configureCompile(MojoMetadataProvider.Context context) {
-		context.inputs( inputs -> {
-			dependsOnConfigurableJavaExecutable( inputs, context, "executable", JavaVersions::forJavacExecutable );
+	private static void configureCompile(GoalMetadataProvider.Context context) {
+		var metadata = context.metadata();
+		metadata.inputs( inputs -> {
+			dependsOnConfigurableJavaExecutable( inputs, context, "executable",
+					context.configuration().getBoolean( "skip" ),
+					JavaVersions::forJavacExecutable );
 		} );
 	}
 }

src/main/java/org/hibernate/search/develocity/plugins/EnforcerConfiguredPlugin.java

@@ -3,11 +3,9 @@
 import java.util.Map;
 import java.util.stream.Collectors;
 
+import org.hibernate.search.develocity.GoalMetadataProvider;
 import org.hibernate.search.develocity.SimpleConfiguredPlugin;
 
-import com.gradle.maven.extension.api.cache.MojoMetadataProvider;
-import com.gradle.maven.extension.api.scan.BuildScanApi;
-
 public class EnforcerConfiguredPlugin extends SimpleConfiguredPlugin {
 
     @Override
@@ -16,20 +14,21 @@ protected String getPluginName() {
     }
 
     @Override
-    protected Map<String, GoalMetadataProvider> getGoalMetadataProviders(BuildScanApi buildScanApi) {
+    protected Map<String, GoalMetadataProvider> getGoalMetadataProviders() {
         return Map.of(
                 "enforce", EnforcerConfiguredPlugin::configureEnforce);
     }
 
-    private static void configureEnforce(MojoMetadataProvider.Context context) {
-        context.inputs(inputs -> {
+    private static void configureEnforce(GoalMetadataProvider.Context context) {
+        var metadata = context.metadata();
+        metadata.inputs(inputs -> {
             dependsOnGav(inputs, context);
             inputs.properties("skip", "fail", "failFast", "failIfNoRules", "rules", "rulesToExecute", "rulesToSkip",
                     "ignoreCache");
             dependsOnOs(inputs);
             dependsOnMavenJavaVersion(inputs);
 
-            String dependencies = context.getProject().getArtifacts().stream()
+            String dependencies = metadata.getProject().getArtifacts().stream()
                     .map(a -> a.getGroupId() + ":" + a.getArtifactId() + ":" + a.getVersion() + ":" + a.getClassifier())
                     .sorted()
                     .collect(Collectors.joining("\n"));
@@ -39,7 +38,7 @@ private static void configureEnforce(MojoMetadataProvider.Context context) {
             inputs.ignore("project", "mojoExecution", "session");
         });
 
-        context.outputs(outputs -> {
+        metadata.outputs(outputs -> {
             outputs.cacheable("If the inputs and dependencies are identical, we should have the same output");
         });
     }

src/main/java/org/hibernate/search/develocity/plugins/FailsafeConfiguredPlugin.java

@@ -2,13 +2,10 @@
 
 import java.util.Map;
 
+import org.hibernate.search.develocity.GoalMetadataProvider;
 import org.hibernate.search.develocity.scan.BuildScanMetadata;
-import org.hibernate.search.develocity.util.MavenConfigs;
 
 import com.gradle.maven.extension.api.cache.MojoMetadataProvider;
-import com.gradle.maven.extension.api.scan.BuildScanApi;
-
-import org.apache.maven.plugin.MojoExecution;
 
 public class FailsafeConfiguredPlugin extends SurefireConfiguredPlugin {
 
@@ -18,47 +15,54 @@ protected String getPluginName() {
 	}
 
 	@Override
-	protected Map<String, GoalMetadataProvider> getGoalMetadataProviders(BuildScanApi buildScanApi) {
+	protected Map<String, GoalMetadataProvider> getGoalMetadataProviders() {
 		return Map.of(
-				"integration-test", context -> configureIntegrationTest( context, buildScanApi )
+				"integration-test", this::configureIntegrationTest
 		);
 	}
 
-	private static void configureIntegrationTest(MojoMetadataProvider.Context context, BuildScanApi buildScanApi) {
+	private void configureIntegrationTest(GoalMetadataProvider.Context context) {
 		configureTest( context );
-		context.inputs( inputs -> {
+		context.metadata().inputs( inputs -> {
 			// We try to be smart about which container is used for the build scan,
 			// because an error would be of little consequence there,
 			// but here it could lead to missing important regressions.
 			// So we just consider all Dockerfiles are used in all integration tests,
 			// and invalidate all integration test caches as soon as one Dockerfile changes.
-			var containersPath = MavenConfigs.getFailsafeSystemProperty( context.getMojoExecution(),
-					"org.hibernate.search.integrationtest.container.directory" );
+			var containersPath = context.configuration()
+					.getFailsafeSystemProperty( "org.hibernate.search.integrationtest.container.directory" );
 			if ( containersPath != null ) {
 				inputs.fileSet( "containers", containersPath, fileSet -> {
 					fileSet.normalizationStrategy(
 							MojoMetadataProvider.Context.FileSet.NormalizationStrategy.RELATIVE_PATH );
 				} );
 			}
 
-			var repackagedJarPath = MavenConfigs.getFailsafeSystemProperty( context.getMojoExecution(),
-					"test.repackaged-jar-path" );
+			var repackagedJarPath = context.configuration()
+					.getFailsafeSystemProperty( "test.repackaged-jar-path" );
 			if ( repackagedJarPath != null ) {
 				inputs.fileSet( "repackaged-jar", repackagedJarPath, fileSet -> {
 					fileSet.normalizationStrategy(
 							MojoMetadataProvider.Context.FileSet.NormalizationStrategy.RELATIVE_PATH );
 				} );
 			}
 		} );
-		if ( !isSkipped( context.getMojoExecution() ) ) {
-			BuildScanMetadata.addFailsafeMetadataToBuildScan( buildScanApi, context.getSession(), context.getMojoExecution() );
+
+		if ( !isSkipped( context ) ) {
+			BuildScanMetadata.addFailsafeMetadata( context );
 		}
 	}
 
-	private static boolean isSkipped(MojoExecution mojoExecution) {
-		return MavenConfigs.getBooleanConfig( mojoExecution, "skip" )
-				|| MavenConfigs.getBooleanConfig( mojoExecution, "skipITs" )
-				|| MavenConfigs.getBooleanConfig( mojoExecution, "skipExec" );
+	@Override
+	protected boolean isSkipped(GoalMetadataProvider.Context context) {
+		return context.configuration().getBoolean( "skip" )
+			   || context.properties().getBoolean( "maven.test.skip" )
+			   || context.configuration().getBoolean( "skipITs" )
+			   || context.properties().getBoolean( "skipITs" )
+			   || context.configuration().getBoolean( "skipTests" )
+			   || context.properties().getBoolean( "skipTests" )
+			   || context.configuration().getBoolean( "skipExec" )
+			   || context.properties().getBoolean( "maven.test.skip.exec" );
 	}
 
 }