addTargetPlatformVariant optionally accepts a feature name

Author: jjohannes

CHANGELOG.md

@@ -8,6 +8,7 @@
 * [Adjusted Rule] [#174](https://github.com/gradlex-org/jvm-dependency-conflict-resolution/issues/174) jakarta.xml.ws-api and jakarta.xml.ws-api merger is now considered (Thanks [KO](https://github.com/ko-at-work) for reporting)
 * [Adjusted Rule] [#201](https://github.com/gradlex-org/jvm-dependency-conflict-resolution/issues/201) Add woodstox:wstx-lgpl to WOODSTOX
 * [Adjusted Rule] [#202](https://github.com/gradlex-org/jvm-dependency-conflict-resolution/issues/202) Remove org.apache.tomcat:tomcat-websocket from JAVAX_WEBSOCKET_API
+* [New] [#229](https://github.com/gradlex-org/jvm-dependency-conflict-resolution/issues/229) Patching: addTargetPlatformVariant optionally accepts a feature name
 * [Fix] [#196](https://github.com/gradlex-org/jvm-dependency-conflict-resolution/issues/196) No longer call eager methods on configurations container (Thanks [Ian Brandt](https://github.com/ianbrandt) for reporting)
 
 ## Version 2.2

src/main/java/org/gradlex/jvm/dependency/conflict/resolution/PatchModule.java

@@ -145,7 +145,17 @@ public void addFeature(String classifier) {
      * See: <a href="https://docs.gradle.org/current/userguide/component_metadata_rules.html#adding_variants_for_native_jars">component_metadata_rules.html#adding_variants_for_native_jars</a>
      */
     public void addTargetPlatformVariant(String classifier, String operatingSystem, String architecture) {
-        getDependencies().getComponents().withModule(module, AddTargetPlatformVariantsMetadataRule.class, r -> r.params(classifier, operatingSystem, architecture));
+        getDependencies().getComponents().withModule(module, AddTargetPlatformVariantsMetadataRule.class, r -> r.params("", classifier, operatingSystem, architecture));
+    }
+
+    /**
+     * Make the Jar with the give 'classifier' known as additional variant with the
+     * OperatingSystemFamily and MachineArchitecture attributes set.
+     * A 'feature' (aka Capability) can optionally be defined to require the variant to be addressed by it.
+     * See: <a href="https://docs.gradle.org/current/userguide/component_metadata_rules.html#adding_variants_for_native_jars">component_metadata_rules.html#adding_variants_for_native_jars</a>
+     */
+    public void addTargetPlatformVariant(String feature, String classifier, String operatingSystem, String architecture) {
+        getDependencies().getComponents().withModule(module, AddTargetPlatformVariantsMetadataRule.class, r -> r.params(feature, classifier, operatingSystem, architecture));
     }
 
     /**

src/main/java/org/gradlex/jvm/dependency/conflict/resolution/rules/AddTargetPlatformVariantsMetadataRule.java

@@ -38,6 +38,7 @@
 @CacheableRule
 public abstract class AddTargetPlatformVariantsMetadataRule implements ComponentMetadataRule {
 
+    private final String feature;
     private final String classifier;
     private final String operatingSystem;
     private final String architecture;
@@ -46,7 +47,8 @@ public abstract class AddTargetPlatformVariantsMetadataRule implements Component
     abstract protected ObjectFactory getObjects();
 
     @Inject
-    public AddTargetPlatformVariantsMetadataRule(String classifier, String operatingSystem, String architecture) {
+    public AddTargetPlatformVariantsMetadataRule(String feature, String classifier, String operatingSystem, String architecture) {
+        this.feature = feature;
         this.classifier = classifier;
         this.operatingSystem = operatingSystem;
         this.architecture = architecture;
@@ -56,6 +58,9 @@ public AddTargetPlatformVariantsMetadataRule(String classifier, String operating
     public void execute(ComponentMetadataContext context) {
         ComponentMetadataDetails details = context.getDetails();
         if (classifier.isEmpty()) {
+            if (!feature.isEmpty()) {
+                throw new IllegalStateException("if classifier is empty, feature must be empty too.");
+            }
             details.withVariant("compile", this::configureAttributes);
             details.withVariant("runtime", this::configureAttributes);
         } else {
@@ -65,10 +70,17 @@ public void execute(ComponentMetadataContext context) {
     }
 
     private void addTargetPlatformVariant(ComponentMetadataDetails details, String nameSuffix, String baseVariant) {
+        String group = details.getId().getGroup();
         String name = details.getId().getName();
         String version = details.getId().getVersion();
 
         details.addVariant(classifier + nameSuffix, baseVariant, variant -> {
+            if (!feature.isEmpty()) {
+                variant.withCapabilities(c -> {
+                    c.removeCapability(group, name);
+                    c.addCapability(group, name + "-" + feature, version);
+                });
+            }
             configureAttributes(variant);
             variant.withFiles(files -> {
                 files.removeAllFiles();

src/test/groovy/org/gradlex/jvm/dependency/conflict/test/patch/AddTargetPlatformVariantTest.groovy

@@ -1,6 +1,7 @@
 package org.gradlex.jvm.dependency.conflict.test.patch
 
 class AddTargetPlatformVariantTest extends AbstractPatchTest {
+
     def "can add target variant"() {
         given:
         buildFile << """
@@ -22,11 +23,47 @@ class AddTargetPlatformVariantTest extends AbstractPatchTest {
             dependencies {
                 implementation("org.openjfx:javafx-base:17.0.10")
             }
+            tasks.register("printJars") {
+                println(configurations.compileClasspath.get().files.joinToString("\\n") { it.name });
+            }
+        """
+
+        expect:
+        String output = printJars().output
+        output == 'javafx-base-17.0.10-win.jar\n'
+    }
+
+    def "can add target variant with feature name"() {
+        given:
+        buildFile << """
+            jvmDependencyConflicts {
+                patch {
+                    module("org.lwjgl:lwjgl") {
+                        addTargetPlatformVariant("natives", "natives-linux", "linux", "x86-64")
+                        addTargetPlatformVariant("natives", "natives-linux-arm64", "linux", "aarch64")
+                        addTargetPlatformVariant("natives", "natives-macos", "macos", "x86-64")
+                        addTargetPlatformVariant("natives", "natives-macos-arm64", "macos", "aarch64")
+                        addTargetPlatformVariant("natives", "natives-windows", "windows", "x86-64")
+                        addTargetPlatformVariant("natives", "natives-windows-arm64", "windows", "aarch64")
+                    }
+                }
+            }
+            configurations.runtimeClasspath {
+                attributes.attribute(OperatingSystemFamily.OPERATING_SYSTEM_ATTRIBUTE, objects.named("windows"))
+                attributes.attribute(MachineArchitecture.ARCHITECTURE_ATTRIBUTE, objects.named("x86-64"))
+            }
+            dependencies {
+                implementation("org.lwjgl:lwjgl:3.3.6")
+                runtimeOnly("org.lwjgl:lwjgl:3.3.6") { capabilities { requireCapability("org.lwjgl:lwjgl-natives") } }
+            }
+            tasks.register("printJars") {
+                println(configurations.runtimeClasspath.get().files.joinToString("\\n") { it.name });
+            }
         """
 
         expect:
-        String output = dependencyInsight("org.openjfx:javafx-base").output
-        output.contains 'windows'
-        output.contains 'x86-64'
+        dependenciesCompile()
+        String output = printJars().output
+        output == 'lwjgl-3.3.6.jar\nlwjgl-3.3.6-natives-windows.jar\n'
     }
 }