Finalize API and define clear limitations

In order to play nice with Gradle's design and the concept of reproduceable builds, I've decided to set a limit on how much the API can help consumers with. Moving forward, there are two clearly defined ways you can use this plugin:
1. Use the API, which is quicker and does a lot of set up. The trade-off is that it is limited to using incoming dependency subtitutions, which can be problematic for complex setups.
2. Use the `ArtifactAccessTransformer` artifact transform class, which is public. Advanced Gradle users can use the transformer how they see fit. JavaDocs have been written to help with its usage, and the responsibility of how it is used rests solely on them.

Additionally, here are some following rules when defining dependencies to be queued:
- Dependencies *must* have a version specified, as per the requirement of dependency subtitutions.
- Dependency constraints can be unversioned *if and only if* there exists a (transitive) dependency that can fulfill it.

Author: Jonathing

at-gradle-demo/build.gradle

@@ -9,12 +9,18 @@ group = 'net.minecraftforge'
 java.toolchain.languageVersion = JavaLanguageVersion.of(17)
 
 dependencies {
-    implementation(libs.coremods) {
-        accessTransformers.configure(it) {
-            config = project.file('accesstransformer.cfg')
+    constraints {
+        // This can be used on transitive dependencies without actually adding them to your project's dependency tree.
+        // While they are added to the module metadata, they don't have any attributes.
+        implementation('net.minecraftforge:coremods') {
+            accessTransformers.configure(it) {
+                config = project.file('accesstransformer.cfg')
+            }
         }
     }
 
+    implementation(libs.coremods)
+
     compileOnly libs.log4j.api
 }
 

at-gradle/src/main/java/net/minecraftforge/accesstransformers/gradle/AccessTransformersConfigurationInternal.java

@@ -4,10 +4,50 @@
  */
 package net.minecraftforge.accesstransformers.gradle;
 
+import org.gradle.api.plugins.ExtensionAware;
+import org.gradle.api.plugins.ExtraPropertiesExtension;
 import org.gradle.api.reflect.HasPublicType;
 import org.gradle.api.reflect.TypeOf;
 
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Objects;
+
 non-sealed interface AccessTransformersConfigurationInternal extends AccessTransformersConfiguration, HasPublicType {
+    String CONFIGS_EXT_PROPERTY = "__accessTransformers_configs";
+
+    static boolean has(Object object) {
+        try {
+            return ((ExtensionAware) object).getExtensions().getExtraProperties().has(CONFIGS_EXT_PROPERTY);
+        } catch (Exception e) {
+            return false;
+        }
+    }
+
+    @SuppressWarnings("unchecked")
+    static List<AccessTransformersConfigurationInternal> get(Object object) {
+        ExtraPropertiesExtension ext;
+        try {
+            ext = ((ExtensionAware) object).getExtensions().getExtraProperties();
+        } catch (Exception e) {
+            // TODO [AccessTransformers][Gradle] Make problem for this
+            throw new RuntimeException("Failed to get extension for " + object, e);
+        }
+
+        try {
+            return (List<AccessTransformersConfigurationInternal>) Objects.requireNonNull(
+                ext.get(CONFIGS_EXT_PROPERTY),
+                "Configs ext property should never be null!"
+            );
+        } catch (ExtraPropertiesExtension.UnknownPropertyException e) {
+            var ret = new LinkedList<AccessTransformersConfigurationInternal>();
+            ext.set(CONFIGS_EXT_PROPERTY, ret);
+            return ret;
+        }
+    }
+
+    AccessTransformersContainerInternal.Options options();
+
     @Override
     default TypeOf<?> getPublicType() {
         return TypeOf.typeOf(AccessTransformersConfiguration.class);

at-gradle/src/main/java/net/minecraftforge/accesstransformers/gradle/AccessTransformersContainer.java

@@ -45,7 +45,7 @@ default void configure(Object dependency) {
     /// Configures the given dependency to use this AccessTransformers container.
     ///
     /// @param dependency The dependency to configure AccessTransformers for
-    /// @param action A configuring action to modify dependency-level AccessTransformer options
+    /// @param action     A configuring action to modify dependency-level AccessTransformer options
     void configure(Object dependency, Action<? super AccessTransformersConfiguration> action);
 
     /// When initially registering an AccessTransformers container, the consumer should define key information regarding

at-gradle/src/main/java/net/minecraftforge/accesstransformers/gradle/AccessTransformersContainerImpl.java

@@ -10,14 +10,11 @@
 import org.gradle.api.file.RegularFileProperty;
 import org.gradle.api.logging.LogLevel;
 import org.gradle.api.model.ObjectFactory;
-import org.gradle.api.plugins.ExtensionAware;
 import org.gradle.api.provider.ListProperty;
 import org.gradle.api.provider.Property;
 import org.gradle.jvm.toolchain.JavaLauncher;
 
 import javax.inject.Inject;
-import java.util.LinkedList;
-import java.util.List;
 
 abstract class AccessTransformersContainerImpl implements AccessTransformersContainerInternal {
     private final OptionsImpl options;
@@ -39,18 +36,10 @@ public AccessTransformersContainer.Options getOptions() {
 
     @Override
     public void configure(Object dependency, Action<? super AccessTransformersConfiguration> action) {
-        var ext = ((ExtensionAware) dependency).getExtensions().getExtraProperties();
-        var attributes = ext.has("__accessTransformers_configs")
-            ? (List<AccessTransformersConfigurationImpl>) ext.get("__accessTransformers_configs")
-            : null;
-        if (attributes == null) {
-            attributes = new LinkedList<>();
-            ext.set("__accessTransformers_configs", attributes);
-        }
-
         var config = new AccessTransformersConfigurationImpl(this.getObjects().fileProperty().convention(this.options.config), this.options);
         action.execute(config);
-        attributes.add(config);
+
+        AccessTransformersConfigurationInternal.get(dependency).add(config);
     }
 
     static abstract class OptionsImpl implements Options {

at-gradle/src/main/java/net/minecraftforge/accesstransformers/gradle/AccessTransformersContainerInternal.java

@@ -5,10 +5,7 @@
 package net.minecraftforge.accesstransformers.gradle;
 
 import org.gradle.api.Action;
-import org.gradle.api.DomainObjectSet;
-import org.gradle.api.NamedDomainObjectProvider;
 import org.gradle.api.Project;
-import org.gradle.api.artifacts.DependencyScopeConfiguration;
 import org.gradle.api.reflect.HasPublicType;
 import org.gradle.api.reflect.TypeOf;