Implement fg.deobf to allow deobf for all dependency types (MinecraftForge#577)

Author: Cypher121

src/common/java/net/minecraftforge/gradle/common/util/Artifact.java

@@ -20,13 +20,17 @@
 
 package net.minecraftforge.gradle.common.util;
 
-import java.io.File;
-import java.util.Locale;
-import org.apache.maven.artifact.versioning.ComparableVersion;
-
 import com.amadornes.artifactural.api.artifact.ArtifactIdentifier;
 import com.google.common.base.Splitter;
 import com.google.common.collect.Iterables;
+import org.apache.maven.artifact.versioning.ComparableVersion;
+import org.gradle.api.artifacts.Dependency;
+import org.gradle.api.artifacts.ResolvedArtifact;
+import org.gradle.api.specs.Spec;
+
+import java.io.File;
+import java.util.Locale;
+import java.util.function.Predicate;
 
 public class Artifact implements ArtifactIdentifier, Comparable<Artifact> {
     //Descriptor parts: group:name:version[:classifier][@extension]
@@ -69,11 +73,32 @@ public static Artifact from(String descriptor) {
         if (ret.classifier != null) ret.file += '-' + ret.classifier;
         ret.file += '.' + ret.ext;
 
-        ret.path = ret.group.replace('.', '/') + '/' + ret.name + '/' + ret.version + '/' + ret.file;
+        ret.path = String.join("/", ret.group.replace('.', '/'), ret.name, ret.version, ret.file);
 
         return ret;
     }
 
+    public static Artifact from(ArtifactIdentifier identifier) {
+        if (identifier instanceof Artifact) {
+            return (Artifact) identifier;
+        }
+
+        StringBuilder builder = new StringBuilder();
+        builder.append(identifier.getGroup()).append(':').append(identifier.getName()).append(':').append(identifier.getVersion());
+        if (identifier.getClassifier() != null && !identifier.getClassifier().isEmpty()) {
+            builder.append(':').append(identifier.getClassifier());
+        }
+
+        builder.append('@');
+        if (identifier.getExtension() == null || identifier.getExtension().isEmpty()) {
+            builder.append("jar");
+        } else {
+            builder.append(identifier.getExtension());
+        }
+
+        return from(builder.toString());
+    }
+
     public static Artifact from(String group, String name, String version, String classifier, String ext) {
         StringBuilder buf = new StringBuilder();
         buf.append(group).append(':').append(name).append(':').append(version);
@@ -84,8 +109,12 @@ public static Artifact from(String group, String name, String version, String cl
         return from(buf.toString());
     }
 
-    public File getLocalPath(File base) {
-        return new File(base, path.replace('/', File.separatorChar));
+    public File getLocalFile(File base) {
+        return new File(base, getLocalPath());
+    }
+
+    public String getLocalPath() {
+        return path.replace('/', File.separatorChar);
     }
 
     public String getDescriptor(){ return descriptor; }
@@ -101,12 +130,42 @@ public File getLocalPath(File base) {
     @Override
     public String getExtension() { return ext;        }
     public String getFilename()  { return file;       }
+
     public boolean isSnapshot()  { return isSnapshot; }
+
+    public Artifact withVersion(String version) {
+        return Artifact.from(group, name, version, classifier, ext);
+    }
+
     @Override
     public String toString() {
         return getDescriptor();
     }
 
+    public Spec<Dependency> asDependencySpec() {
+        return (dep) -> group.equals(dep.getGroup()) && name.equals(dep.getName()) && version.equals(dep.getVersion());
+    }
+
+    public Predicate<ResolvedArtifact> asArtifactMatcher() {
+        return (art) -> {
+            String theirClassifier;
+            if (art.getClassifier() == null) {
+                theirClassifier = "";
+            } else {
+                theirClassifier = art.getClassifier();
+            }
+
+            String theirExt;
+            if (art.getExtension().isEmpty()) {
+                theirExt = "jar";
+            } else {
+                theirExt = art.getExtension();
+            }
+
+            return (classifier == null || classifier.equals(theirClassifier)) && (ext == null || ext.equals(theirExt));
+        };
+    }
+
     @Override
     public int compareTo(Artifact o) {
         int ret = 0;

src/userdev/java/net/minecraftforge/gradle/userdev/DependencyManagementExtension.java

@@ -0,0 +1,45 @@
+/*
+ * ForgeGradle
+ * Copyright (C) 2018 Forge Development LLC
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301
+ * USA
+ */
+
+package net.minecraftforge.gradle.userdev;
+
+import groovy.lang.GroovyObjectSupport;
+import net.minecraftforge.gradle.userdev.util.DependencyRemapper;
+import org.gradle.api.Project;
+import org.gradle.api.artifacts.Dependency;
+
+public class DependencyManagementExtension extends GroovyObjectSupport {
+    public static final String EXTENSION_NAME = "fg";
+    private final Project project;
+    private final DependencyRemapper remapper;
+
+    public DependencyManagementExtension(Project project, DependencyRemapper remapper) {
+        this.project = project;
+        this.remapper = remapper;
+    }
+
+    @SuppressWarnings("unused")
+    public Dependency deobf(Object dependency) {
+        Dependency baseDependency = project.getDependencies().create(dependency);
+        project.getConfigurations().getByName(UserDevPlugin.OBF).getDependencies().add(baseDependency);
+
+        return remapper.remap(baseDependency);
+    }
+}