Migrate to ArtifactView API

.github/workflows/ci.yml

@@ -112,6 +112,17 @@ jobs:
       - name: Copy CI gradle.properties
         run: mkdir -p ~/.gradle ; cp .github/ci-gradle.properties ~/.gradle/gradle.properties
 
+      - name: Run Gradle Plugin Tests
+        run: |
+          cd plugin-build
+          ./gradlew test
+
+      - name: Publish Test Report
+        uses: mikepenz/action-junit-report@v6
+        if: success() || failure() # always run even if the previous step fails
+        with:
+          report_paths: 'plugin-build/plugin/build/test-results/test/TEST-*.xml'
+
       - name: Publish plugin locally
         run: |
           cd plugin-build

.gitignore

@@ -20,4 +20,6 @@ docs
 /vendor/*
 .kotlin/
 
-iosApp/iosApp.xcodeproj
+iosApp/iosApp.xcodeproj
+/gradle-user-home/
+/tmp/

plugin-build/plugin/build.gradle.kts

@@ -64,6 +64,19 @@ dependencies {
 
     // lint rules
     lintChecks(baseLibs.android.lint.gradle)
+
+    // test dependencies
+    testImplementation(gradleTestKit())
+    testImplementation(kotlin("test"))
+    testImplementation("org.junit.jupiter:junit-jupiter:5.10.1")
+    testRuntimeOnly("org.junit.platform:junit-platform-launcher")
+}
+
+tasks.named<Test>("test") {
+    useJUnitPlatform()
+    javaLauncher.set(javaToolchains.launcherFor {
+        languageVersion.set(JavaLanguageVersion.of(17))
+    })
 }
 
 mavenPublishing {

plugin-build/plugin/src/main/kotlin/com/mikepenz/aboutlibraries/plugin/AboutLibrariesPluginAndroidExtension.kt

@@ -38,9 +38,11 @@ private fun configureAndroidTasks(project: Project, extension: AboutLibrariesExt
         it.group = ""
         it.variant.set(variant.name)
         it.outputDirectory.set(resultsResDirectory)
-        it.configureOutputFile(resultsDirectory.map { dir ->
-            @Suppress("DEPRECATION")
-            dir.file(extension.export.outputFileName.get())
+        it.configureOutputFile(resultsDirectory.flatMap { dir ->
+            extension.export.outputFileName.map { filename ->
+                @Suppress("DEPRECATION")
+                dir.file(filename)
+            }
         })
         it.configure()
     }
@@ -52,9 +54,11 @@ private fun configureAndroidTasks(project: Project, extension: AboutLibrariesExt
     // task to generate libraries, and their license into the build folder (not hooked to the build task)
     project.tasks.configure("exportLibraryDefinitions${variantName}", AboutLibrariesTask::class.java) {
         it.variant.set(variant.name)
-        it.configureOutputFile(resultsDirectory.map { dir ->
-            @Suppress("DEPRECATION")
-            dir.file(extension.export.outputFileName.get())
+        it.configureOutputFile(resultsDirectory.flatMap { dir ->
+            extension.export.outputFileName.map { filename ->
+                @Suppress("DEPRECATION")
+                dir.file(filename)
+            }
         })
         it.configure()
     }

plugin-build/plugin/src/main/kotlin/com/mikepenz/aboutlibraries/plugin/AboutLibrariesTask.kt

@@ -43,16 +43,21 @@ abstract class AboutLibrariesTask : BaseAboutLibrariesTask() {
         } else {
             val projectDirectory = project.layout.projectDirectory
             val buildDirectory = project.layout.buildDirectory
+
+            // Capture extension values during configuration time to avoid accessing
+            // extension (which references project) during Provider evaluation
+            val exports = extension.exports
+            val export = extension.export
 
             @Suppress("DEPRECATION")
             val fileNameProvider = project.provider {
-                val config = extension.exports.findByName(variant.getOrElse(""))
-                config?.outputFileName?.orNull ?: extension.export.outputFileName.get()
+                val config = exports.findByName(variant.getOrElse(""))
+                config?.outputFileName?.orNull ?: export.outputFileName.get()
             }
 
             val outputFileProvider = project.provider {
-                val config = extension.exports.findByName(variant.getOrElse(""))
-                config?.outputFile?.orNull ?: extension.export.outputFile.orNull
+                val config = exports.findByName(variant.getOrElse(""))
+                config?.outputFile?.orNull ?: export.outputFile.orNull
             }
 
             val providers = project.providers
@@ -61,10 +66,10 @@ abstract class AboutLibrariesTask : BaseAboutLibrariesTask() {
             this.outputFile.set(
                 providers.gradleProperty("${PROP_PREFIX}${PROP_EXPORT_OUTPUT_FILE}").map { path -> projectDirectory.file(path) }.orElse(
                     providers.gradleProperty("${PROP_PREFIX}${PROP_EXPORT_OUTPUT_PATH}").map { path -> projectDirectory.file(path) }.orElse(
-                        providers.gradleProperty("${PROP_PREFIX}${PROP_EXPORT_PATH}").map { path -> projectDirectory.dir(path).file(fileNameProvider.get()) }.orElse(
-                            providers.gradleProperty(PROP_EXPORT_PATH).map { path -> projectDirectory.dir(path).file(fileNameProvider.get()) }).orElse(
+                        providers.gradleProperty("${PROP_PREFIX}${PROP_EXPORT_PATH}").flatMap { path -> fileNameProvider.map { filename -> projectDirectory.dir(path).file(filename) } }.orElse(
+                            providers.gradleProperty(PROP_EXPORT_PATH).flatMap { path -> fileNameProvider.map { filename -> projectDirectory.dir(path).file(filename) } }).orElse(
                             outputFileProvider.orElse(
-                                buildDirectory.dir("generated/aboutLibraries/").map { it.file(fileNameProvider.get()) }
+                                buildDirectory.dir("generated/aboutLibraries/").flatMap { dir -> fileNameProvider.map { filename -> dir.file(filename) } }
                             )
                         )
                     )

plugin-build/plugin/src/main/kotlin/com/mikepenz/aboutlibraries/plugin/BaseAboutLibrariesTask.kt

@@ -8,10 +8,16 @@ import com.mikepenz.aboutlibraries.plugin.util.LibraryPostProcessor
 import org.gradle.api.DefaultTask
 import org.gradle.api.artifacts.Configuration
 import org.gradle.api.file.DirectoryProperty
+import org.gradle.api.provider.ListProperty
 import org.gradle.api.provider.MapProperty
 import org.gradle.api.provider.Property
 import org.gradle.api.provider.SetProperty
-import org.gradle.api.tasks.*
+import org.gradle.api.tasks.Input
+import org.gradle.api.tasks.InputDirectory
+import org.gradle.api.tasks.Internal
+import org.gradle.api.tasks.Optional
+import org.gradle.api.tasks.PathSensitive
+import org.gradle.api.tasks.PathSensitivity
 import org.slf4j.LoggerFactory
 
 abstract class BaseAboutLibrariesTask : DefaultTask() {
@@ -91,6 +97,9 @@ abstract class BaseAboutLibrariesTask : DefaultTask() {
     @get:Internal
     internal abstract val variantToDependencyData: MapProperty<String, List<DependencyData>>
 
+    @get:Internal
+    internal abstract val configurationNames: ListProperty<String>
+
     open fun configure() {
         excludeFields.set(project.provider {
             val config = extension.exports.findByName(variant.getOrElse(""))
@@ -123,7 +132,9 @@ abstract class BaseAboutLibrariesTask : DefaultTask() {
 
         val filter = filterVariants.get() + (variant.orNull?.let { arrayOf(it) } ?: emptyArray())
 
-        val dependencies = project.configurations.filterNot { config ->
+        // PERFORMANCE: Store only configuration names during configuration time
+        // Actual resolution happens during task execution when variantToDependencyData is accessed
+        val selectedConfigNames = project.configurations.filterNot { config ->
             config.shouldSkip(includeTestVariants.get())
         }.filter { config ->
             val cn = config.name
@@ -160,14 +171,25 @@ abstract class BaseAboutLibrariesTask : DefaultTask() {
                     false
                 }
             }
-        }.associate { config ->
-            config.name to DependencyCollector(includePlatform.get())
-                .loadDependenciesFromConfiguration(project, config.incoming.resolutionResult.rootComponent)
-        }
+        }.map { it.name }
 
+        configurationNames.set(selectedConfigNames)
+
+        // PERFORMANCE: Wrap resolution in a provider that's only evaluated during task execution
         variantToDependencyData.set(project.providers.provider {
+            if (LOGGER.isDebugEnabled) LOGGER.debug("==> ABOUTLIBRARIES: Provider evaluated - dependency resolution starting (EXECUTION TIME)")
             val target = mutableMapOf<String, List<DependencyData>>()
-            dependencies.onEach { (name, result) -> target[name] = result.get() }
+            for (configName in configurationNames.get()) {
+                val config = project.configurations.getByName(configName)
+                // Resolution happens HERE during task execution, not during configuration
+                val dependencyData = DependencyCollector(includePlatform.get())
+                    .loadDependenciesFromConfiguration(
+                        project,
+                        config.incoming.resolutionResult.rootComponent
+                    ).get()
+                target[configName] = dependencyData
+            }
+            if (LOGGER.isDebugEnabled) LOGGER.debug("==> ABOUTLIBRARIES: Provider evaluation complete")
             target
         })
     }

plugin-build/plugin/src/main/kotlin/com/mikepenz/aboutlibraries/plugin/util/DependencyCollector.kt

@@ -1,11 +1,19 @@
 package com.mikepenz.aboutlibraries.plugin.util
 
-import com.mikepenz.aboutlibraries.plugin.mapping.*
+import com.mikepenz.aboutlibraries.plugin.mapping.Developer
+import com.mikepenz.aboutlibraries.plugin.mapping.Funding
+import com.mikepenz.aboutlibraries.plugin.mapping.License
+import com.mikepenz.aboutlibraries.plugin.mapping.Organization
+import com.mikepenz.aboutlibraries.plugin.mapping.Scm
 import org.apache.maven.model.Dependency
 import org.apache.maven.model.Model
 import org.apache.maven.model.Parent
 import org.apache.maven.model.Repository
-import org.apache.maven.model.building.*
+import org.apache.maven.model.building.DefaultModelBuilderFactory
+import org.apache.maven.model.building.DefaultModelBuildingRequest
+import org.apache.maven.model.building.FileModelSource
+import org.apache.maven.model.building.ModelBuildingRequest
+import org.apache.maven.model.building.ModelSource2
 import org.apache.maven.model.resolution.ModelResolver
 import org.gradle.api.Project
 import org.gradle.api.artifacts.Configuration
@@ -18,7 +26,9 @@ import org.gradle.api.artifacts.result.ResolvedComponentResult
 import org.gradle.api.artifacts.result.ResolvedDependencyResult
 import org.gradle.api.artifacts.result.ResolvedVariantResult
 import org.gradle.api.attributes.Attribute
-import org.gradle.api.attributes.Category.*
+import org.gradle.api.attributes.Category.CATEGORY_ATTRIBUTE
+import org.gradle.api.attributes.Category.ENFORCED_PLATFORM
+import org.gradle.api.attributes.Category.REGULAR_PLATFORM
 import org.gradle.api.provider.Provider
 import org.slf4j.LoggerFactory
 import java.io.File
@@ -228,6 +238,9 @@ internal class DependencyCollector(
 
     /**
      * Fetches the pom files for all [ResolvedVariantResult]s.
+     * 
+     * PERFORMANCE: Uses ArtifactView API instead of deprecated lenientConfiguration to avoid
+     * triggering configuration resolution during Gradle configuration phase.
      *
      * Original Code is based on: https://github.com/cashapp/licensee/blob/1.13.0/src/main/kotlin/app/cash/licensee/task.kt#L152
      * Copyright (C) 2021 Square, Inc.
@@ -237,10 +250,17 @@ internal class DependencyCollector(
         dependencies: DependencyHandler,
         configurations: ConfigurationContainer,
     ): List<DependencyCoordinatesWithPomFile> {
-        fun Configuration.artifacts() = resolvedConfiguration.lenientConfiguration.allModuleDependencies.flatMap { it.allModuleArtifacts }
+        if (LOGGER.isDebugEnabled) LOGGER.debug("==> ABOUTLIBRARIES: fetchPomFiles called - resolving ${this.size} dependencies")
+        // Use ArtifactView API which is configuration-cache compatible and lazy
+        fun Configuration.artifactsViaView() = incoming.artifactView { config ->
+            config.lenient(true)
+        }.artifacts.map { it.file to it.id.componentIdentifier }
 
         val pomDependencies = map { dependencies.create(it.pomCoordinate()) }.toTypedArray()
+
         val withVariants = configurations.detachedConfiguration(*pomDependencies).apply {
+            isCanBeConsumed = false
+            isCanBeResolved = true
             for (variant in variants) {
                 attributes {
                     val variantAttrs = variant.attributes
@@ -250,13 +270,19 @@ internal class DependencyCollector(
                     }
                 }
             }
-        }.artifacts()
-
-        val withoutVariants = configurations.detachedConfiguration(*pomDependencies).artifacts()
-        return (withVariants + withoutVariants).map {
-            // Cast is safe because all resolved artifacts are pom files.
-            val coordinates = (it.id.componentIdentifier as ModuleComponentIdentifier).toDependencyCoordinates()
-            DependencyCoordinatesWithPomFile(coordinates, it.file)
+        }.artifactsViaView()
+
+        val withoutVariants = configurations.detachedConfiguration(*pomDependencies).apply {
+            isCanBeConsumed = false
+            isCanBeResolved = true
+        }.artifactsViaView()
+
+        return (withVariants + withoutVariants).mapNotNull { (file, componentId) ->
+            // Only process module components (not project components)
+            if (componentId is ModuleComponentIdentifier) {
+                val coordinates = componentId.toDependencyCoordinates()
+                DependencyCoordinatesWithPomFile(coordinates, file)
+            } else null
         }.distinctBy { it.dependencyCoordinates }
     }