Dependency Analysis Gradle Plugin

The variant-artifacts library simplifies sharing non-standard artifacts (like code coverage data or metadata) between Gradle projects. It uses a contract-based approach to avoid cross-project mutation and ensure compatibility with Gradle's isolated projects.

There are three core components in this model:

1. ArtifactDescription: Defines the contract between the producer and the consumer. It specifies the Attribute used for matching and a categoryName.
2. The Producer: Registers a task that produces an output and uses an interProjectPublisher to publish that task's output as an artifact.
3. The Consumer (Aggregator): Uses an interProjectResolver to find and collect artifacts from other projects. It can then aggregate these files into a single task.

To link projects safely, the consumer should declare dependencies on the producer projects using the configuration name derived from the ArtifactDescription's Kind enum.

To sign your plugin artifacts, you must generate a GPG key and publish the public portion to a keyserver so Maven Central can verify your signatures.

1. Generate a key: Use GPG (e.g., via GitHub's guide).
2. Find your Key ID: Run gpg -K. The Key ID is the last 8 characters of the 40-character fingerprint line.
3. Publish to a keyserver:

   gpg --send-keys --keyserver keyserver.ubuntu.com <YOUR_KEY_ID>

4. Verify publication:

   gpg --recv-keys --keyserver keyserver.ubuntu.com <YOUR_KEY_ID>

$ gpg -K
    /Users/trobalik/.gnupg/pubring.kbx
    ----------------------------------
    sec   rsa4096 2020-01-01 [SC]
          W7WQ5NZWC8S339RVAAOCR0SCMV7T00FKDHG570SZ
    uid           [ultimate] Tony Robalik <you@email.com>
    ssb   rsa4096 2020-01-01 [E]

# Example Key ID: DHG570SZ
$ gpg --send-keys --keyserver keyserver.ubuntu.com DHG570SZ

Before releasing, publish a snapshot version to verify the plugin works in a real project.

1. Set version to snapshot: version = "0.1.0-SNAPSHOT".
2. Run publishing tasks:

   ./gradlew publishMyPluginPluginMarkerMavenPublicationToSonatypeRepository publishPluginPublicationToSonatypeRepository

3. Consume in a test project: In the consumer's settings.gradle (or settings.gradle.kts), you must explicitly add the Sonatype snapshot repository to pluginManagement because the plugins {} block only looks at the Gradle Plugin Portal by default:

   pluginsManagement {
     repositories {
       maven { url "https://central.sonatype.com/repository/maven-snapshots/" }
       gradlePluginPortal()
     }
   }

4. Apply the plugin:

   plugins {
     id("com.domain.my-plugin") version "0.1.0-SNAPSHOT"
   }

// In consumer's settings.gradle
pluginsManagement {
  repositories {
    maven {
      url "https://central.sonatype.com/repository/maven-snapshots/"
    }
    gradlePluginPortal()
  }
}

When publishing a Gradle plugin, you must publish both the plugin jar and the plugin marker artifact. The marker artifact is required for users to apply your plugin using the plugins {} DSL.

Required plugins:

• java-gradle-plugin
• maven-publish
• signing

Key Configuration Requirements:

• Javadoc and Sources: OSS libraries on Maven Central must include these. Use java.withJavadocJar() and java.withSourcesJar().
• Plugin Marker: Use afterEvaluate to configure the automatically created ...PluginMarkerMaven publication.
• POM Metadata: Ensure you provide name, description, URL, licenses, developers, and SCM information.
• Signing: You must sign both the plugin publication and the pluginMarker publication.

plugins {
  `java-gradle-plugin` 
  `maven-publish`      
  signing              
}

java {
  withJavadocJar()
  withSourcesJar()
}

publishing {
  publications {
    afterEvaluate {
      named<MavenPublication>("myPluginPluginMarkerMaven") {
        pom {
          // ... metadata ...
        }
      }
    }

    create<MavenPublication>("plugin") {
      from(components["java"])
      // ... version mapping and pom ...
    }
  }

  repositories {
    // Configure Sonatype repositories based on version (SNAPSHOT vs Release)
  }
}

afterEvaluate {
  signing {
    sign(publishing.publications["plugin"], publishing.publications["myPluginPluginMarkerMaven"])
  }
}

To act as a producer, follow these steps:

1. Define an ArtifactDescription (usually via an enum class Kind : ArtifactDescription<T>).
2. Create an interProjectPublisher using the Publisher.Companion.interProjectPublisher extension function, passing the current project and the artifactDescription.
3. Register a task that produces the desired output.
4. Call publisher.publish(task.outputProperty) to link the task's output to the publisher.

import com.autonomousapps.artifacts.Publisher.Companion.interProjectPublisher

class ProducerPlugin : Plugin<Project> {
  override fun apply(target: Project): Unit = target.run {
    val publisher = interProjectPublisher(
      project = this,
      artifactDescription = MyArtifacts.Kind.PROJECT_PATH,
    )

    val publishPath = tasks.register("publishPath", PublishTask::class.java) {
      t.projectPath.set(target.path)
      t.output.set(layout.buildDirectory.file("path.txt"))
    }

    publisher.publish(publishPath.flatMap { it.output })
  }
}