Improved DependencyCreationExtension and simplified debug logging.

Author: ianbrandt

build-logic/src/main/kotlin/org/sdkotlin/buildlogic/artifacts/dsl/AttributesDependencyCreationExtension.kt

@@ -12,7 +12,7 @@ import org.slf4j.LoggerFactory
  * A [DependencyHandler] extension that sets the attributes for variants of a
  * declared [Dependency].
  */
-class AttributesDependencyCreationExtension(
+abstract class AttributesDependencyCreationExtension(
 	private val dependencyHandler: DependencyHandler,
 	private val providers: ProviderFactory,
 	private val attributesConfigureAction: AttributeContainer.() -> Unit,
@@ -24,15 +24,10 @@ class AttributesDependencyCreationExtension(
 		providers.provider {
 
 			// TODO: Remove debug logging.
-			try {
-				throw RuntimeException(
-					"Attributes dependency helper stacktrace"
-				)
-			} catch (e: RuntimeException) {
-				logger.warn(
-					"Creating $notation...", e
-				)
-			}
+			logger.warn(
+				"Creating $notation...",
+				RuntimeException("Attributes dependency helper stacktrace")
+			)
 
 			val dependency = dependencyHandler.create(notation)
 

build-logic/src/main/kotlin/org/sdkotlin/buildlogic/artifacts/dsl/DependencyCreationExtension.kt

@@ -2,13 +2,24 @@ package org.sdkotlin.buildlogic.artifacts.dsl
 
 import org.gradle.api.artifacts.Dependency
 import org.gradle.api.artifacts.dsl.DependencyHandler
+import org.gradle.api.plugins.ExtensionAware
 import org.gradle.api.provider.Provider
 
 /**
  * An invokable interface for [DependencyHandler] extensions that create
  * dependencies. Facilitates calling the extensions as unqualified helper
  * functions.
  */
-fun interface DependencyCreationExtension {
+interface DependencyCreationExtension : ExtensionAware {
+
+	/**
+	 * Ivocable from the Kotlin DSL.
+	 */
 	operator fun invoke(notation: Any): Provider<Dependency>
+
+	/**
+	 * Invokable from the Groovy DSL.
+	 */
+	@Suppress("unused")
+	fun call(notation: Any): Provider<Dependency> = invoke(notation)
 }

build-logic/src/main/kotlin/org/sdkotlin/buildlogic/plugins/resources/ResourceConfigurationVariants.kt

@@ -68,23 +68,17 @@ abstract class ResourceConfigurationVariants @Inject constructor(
 			// Create a variant-aware consumable configuration for this resource
 			// configuration's artifacts.
 			@Suppress("UnstableApiUsage")
-			project.configurations.consumable(theConsumableConfigurationName)
-				.configure {
-					// TODO: Remove debug logging.
-					try {
-						throw RuntimeException(
-							"Configuration configureAction stacktrace"
-						)
-					} catch (e: RuntimeException) {
-						logger.warn(
-							"Configuring $theConsumableConfigurationName...", e
-						)
-					}
+			project.configurations.consumable(theConsumableConfigurationName) {
+				// TODO: Remove debug logging.
+				logger.warn(
+					"Configuring $theConsumableConfigurationName...",
+					RuntimeException("Configuration configureAction stacktrace")
+				)
 
-					attributes {
-						applyVariantAttributes()
-					}
+				attributes {
+					applyVariantAttributes()
 				}
+			}
 
 			// Any files in "src/main/<resourceConfigurationName>/" are
 			// resources for this configuration. No build step is necessary, so

build-logic/src/main/kotlin/org/sdkotlin/buildlogic/plugins/resources/ResourceConfigurations.kt

@@ -2,6 +2,7 @@ package org.sdkotlin.buildlogic.plugins.resources
 
 import org.gradle.api.NamedDomainObjectSet
 import org.gradle.api.Project
+import org.gradle.api.attributes.AttributeContainer
 import org.sdkotlin.buildlogic.artifacts.dsl.AttributesDependencyCreationExtension
 import org.sdkotlin.buildlogic.artifacts.dsl.DependencyCreationExtension
 import javax.inject.Inject
@@ -46,30 +47,29 @@ abstract class ResourceConfigurations @Inject constructor(
 		name: String,
 		configureAction: ResourceConfiguration.() -> Unit = {},
 	) {
-
 		val resourceConfiguration =
 			project.objects.newInstance(ResourceConfiguration::class.java, name)
 
 		configureAction(resourceConfiguration)
 
-		with(resourceConfiguration) {
-
-			// Add a `DependencyHandler` extension for declaring a dependency on
-			// the resource configuration's artifact variant.
-			project.dependencies.extensions.add(
-				DependencyCreationExtension::class.java,
-				dependencyHandlerExtensionName.get(),
-				AttributesDependencyCreationExtension(
-					dependencyHandler = project.dependencies,
-					providers = project.providers,
-					attributesConfigureAction = {
-						applyConfigurationAttributes()
-					},
-				)
-			)
+		// Add a `DependencyHandler` extension for declaring a dependency on
+		// the resource configuration's artifact variant.
+		project.dependencies.extensions.create(
+			DependencyCreationExtension::class.java,
+			resourceConfiguration.dependencyHandlerExtensionName.get(),
+			AttributesDependencyCreationExtension::class.java,
+			project.dependencies,
+			project.providers,
+			{ container: AttributeContainer ->
+				resourceConfiguration.run {
+					container.applyConfigurationAttributes()
+				}
+			},
+		)
 
-			// Create a default variant for this resource configuration if none
-			// are added by the user.
+		// Create a default variant for this resource configuration if none
+		// are added by the user.
+		with(resourceConfiguration) {
 			if (resourceConfigurationVariants.isEmpty()) {
 				resourceConfigurationVariants.variant(name)
 			}