Work attempting to bypass gradle's crappy caching.

It caches FAILURES and uses those over the successes we provide in the custom repos!
Other work directed twards cleaning up the api, and moved to using maven local which bypasses SOME of the caching and prevents the artifacts from our custom repo from being copied to the gradle central cache.

2 files changed, 252 insertions, 0 deletions

diff --git a/src/shared/java/com/amadornes/artifactural/base/util/HashFunction.java b/src/shared/java/com/amadornes/artifactural/base/util/HashFunction.java
new file mode 100644
index 0000000..275b53c
--- /dev/null
+++ b/src/shared/java/com/amadornes/artifactural/base/util/HashFunction.java
@@ -0,0 +1,112 @@
+package com.amadornes.artifactural.base.util;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.math.BigInteger;
+import java.nio.ByteBuffer;
+import java.nio.charset.StandardCharsets;
+import java.security.MessageDigest;
+import java.security.NoSuchAlgorithmException;
+import java.util.Locale;
+
+import org.apache.commons.io.IOUtils;
+
+//These are all standard hashing functions the JRE is REQUIRED to have, so add a nice factory that doesnt require catching annoying exceptions;
+public enum HashFunction {
+    MD5("md5", 32),
+    SHA1("SHA-1", 40),
+    SHA256("SHA-256", 64);
+
+    private String algo;
+    private String pad;
+
+    private HashFunction(String algo, int length) {
+        this.algo = algo;
+        this.pad = String.format("%0" + length + "d", 0);
+    }
+
+    public String getExtension() {
+         return this.name().toLowerCase(Locale.ENGLISH);
+    }
+
+    public Instance create() {
+        return new Instance();
+    }
+
+    public MessageDigest get() {
+        try {
+            return MessageDigest.getInstance(algo);
+        } catch (NoSuchAlgorithmException e) {
+            throw new RuntimeException(e); //Never happens
+        }
+    }
+
+    public String hash(File file) throws IOException {
+        try (FileInputStream fin = new FileInputStream(file)) {
+            return hash(fin);
+        }
+    }
+
+    public String hash(Iterable<File> files) throws IOException {
+        MessageDigest hash = get();
+        byte[] buf = new byte[1024];
+
+        for (File file : files) {
+            if (!file.exists())
+                continue;
+
+            try (FileInputStream fin = new FileInputStream(file)) {
+                int count = -1;
+                while ((count = fin.read(buf)) != -1)
+                    hash.update(buf, 0, count);
+            }
+        }
+        return pad(new BigInteger(1, hash.digest()).toString(16));
+    }
+
+    public String hash(String data) {
+        return hash(data.getBytes(StandardCharsets.UTF_8));
+    }
+
+    public String hash(InputStream stream) throws IOException {
+        return hash(IOUtils.toByteArray(stream));
+    }
+
+    public String hash(byte[] data) {
+        return pad(new BigInteger(1, get().digest(data)).toString(16));
+    }
+
+    public String pad(String hash) {
+        return (pad + hash).substring(hash.length());
+    }
+
+    public class Instance {
+        private MessageDigest digest = HashFunction.this.get();
+        public void update(byte input) {
+            digest.update(input);
+        }
+        public void update(byte[] input) {
+            digest.update(input);
+        }
+        public void update(byte[] input, int offset, int length) {
+            digest.update(input, offset, length);
+        }
+        public void update(ByteBuffer input) {
+            digest.update(input);
+        }
+        public void update(String input) {
+            update(input.getBytes(StandardCharsets.UTF_8));
+        }
+        public void update(int input) {
+            update(new byte[] { (byte)((input & 0xFF000000) >> 24), (byte)((input & 0xFF000000) >> 16), (byte)((input & 0xFF000000) >> 8), (byte)((input & 0xFF000000))});
+        }
+        public byte[] digest() {
+            return digest.digest();
+        }
+        public String finish() {
+            return pad(new BigInteger(1, digest()).toString(16));
+        }
+    }
+}
diff --git a/src/shared/java/com/amadornes/artifactural/base/util/PatternReplace.java b/src/shared/java/com/amadornes/artifactural/base/util/PatternReplace.java
new file mode 100644
index 0000000..80216d6
--- /dev/null
+++ b/src/shared/java/com/amadornes/artifactural/base/util/PatternReplace.java
@@ -0,0 +1,140 @@
+package com.amadornes.artifactural.base.util;
+
+import java.util.Map;
+
+public class PatternReplace {
+    /*
+     * Replaces a patterened string, with support for optional groups.
+     * Example:
+     *   Values:
+     *     group: net/minecraftforge
+     *     name: forge
+     *     version: 1.0
+     *     ext: jar
+     *
+     *   Example: [group]/[name]/[version]/[name]-[version](-[classifier]).[ext]
+     *     {classifier: test} net/minecraftforge/forge/1.0/forge-1.0-test.jar
+     *     {classifier: null} net/minecraftforge/forge/1.0/forge-1.0.jar
+     *
+     *   Nested Optionals are supported:
+     *     Example: [group]/[name]/[version]/[name]-[version](-[classifier](-[suffix])).[ext]
+     *     {classifier: test, suffix: foo} net/minecraftforge/forge/1.0/forge-1.0-test-foo.jar
+     *     {classifier: test, suffix: foo} net/minecraftforge/forge/1.0/forge-1.0-test.jar
+     *     {classifier: null, suffix: foo} net/minecraftforge/forge/1.0/forge-1.0.jar
+     *
+     *   Compound optionals are supported:
+     *     Example: [group]/[name]/[version]/[name]-[version](-[classifier]-[suffix]).[ext]
+     *     {classifier: test, suffix: foo} net/minecraftforge/forge/1.0/forge-1.0-test-foo.jar
+     *     {classifier: test, suffix: null} net/minecraftforge/forge/1.0/forge-1.0.jar
+     *     {classifier: null, suffix: foo} net/minecraftforge/forge/1.0/forge-1.0.jar
+     *
+     *
+     *   TODO: Support nested names?
+     *     Example: [group]/[name]/[version]/[name]-[version](-[classifier[suffix]]).[ext]
+     *     {classifierFoo: test, suffix: Foo} net/minecraftforge/forge/1.0/forge-1.0-test.jar
+     *     {classifierFoo: null, suffix: Foo} net/minecraftforge/forge/1.0/forge-1.0.jar
+     */
+    public static String replace(String pattern, Map<String, String> values) {
+        if (pattern == null) return null;
+        if (pattern.isEmpty()) return "";
+
+        Optional optional = null;
+        StringBuffer name = null;
+        StringBuffer ret = new StringBuffer();
+
+        char[] chars = pattern.toCharArray();
+        for (int x = 0; x < chars.length; x++) {
+            char c = chars[x];
+            if (c == '\\') {
+                if (x == chars.length -1)
+                    throw new IllegalArgumentException("Escape character can not be end of pattern: " + pattern);
+                x++;
+                ret.append(chars[x]);
+                continue;
+            }
+            switch (c) {
+                case '[':
+                    if (name != null)
+                        throw new IllegalArgumentException("Nested names are not supported @ " + x + " : " + pattern);
+                    name = new StringBuffer();
+                    break;
+                case ']':
+                    if (name == null)
+                        throw new IllegalArgumentException("Name closing found without opening @ " + x + " : " + pattern);
+                    String key = name.toString();
+                    if (key.isEmpty())
+                        throw new IllegalArgumentException("Name can not be empty @ " + x + ": " + pattern);
+                    if (optional != null)
+                        optional.setKey(key, values);
+                    else
+                        ret.append(values.get(key)); // appends 'null' if missing, if you want "" then use ([name])
+                        // Should we have this default to not replacing at all if value is not set to allow chaining?
+                        //   Meaning: '[key]' == '[key]' if 'key' is not set.
+                        //   Current: '[key]' == 'null'
+                    name = null;
+                    break;
+                case '(':
+                    optional = new Optional(optional);
+                    break;
+                case ')':
+                    if (optional == null)
+                        throw new IllegalArgumentException("Optional closing found without opening @ " + x + ": " + pattern);
+                    optional = optional.finish(x, pattern, ret);
+                    break;
+                default:
+                    if (name != null)
+                        name.append(c);
+                    else if (optional != null)
+                        optional.append(c);
+                    else
+                        ret.append(c);
+            }
+        }
+        if (optional != null)
+            throw new IllegalArgumentException("Missing closing of optional value: " + pattern);
+        if (name != null)
+            throw new IllegalArgumentException("Missing closing of name entry: " + pattern);
+        return ret.toString();
+    }
+
+    public static String quote(String value) {
+        return value.replaceAll("\\", "\\\\")
+                .replaceAll("(", "\\(")
+                .replaceAll(")", "\\)")
+                .replaceAll("[", "\\[")
+                .replaceAll("]", "\\]");
+    }
+
+    private static class Optional {
+        private final Optional parent;
+        private final StringBuffer buf = new StringBuffer();
+        private boolean hadAll = true;
+        private boolean hadValue = false;
+
+        private Optional(Optional parent) {
+            this.parent = parent;
+        }
+
+        public void append(char c) {
+            buf.append(c);
+        }
+
+        private void setKey(String key, Map<String, String> values) {
+            hadValue = true;
+            String value = values.get(key);
+            if (value != null && !value.isEmpty()) {
+                hadAll &= true;
+                buf.append(value);
+            } else
+                hadAll = false;
+        }
+
+        public Optional finish(int position, String pattern, StringBuffer ret) {
+            if (!hadValue)
+                throw new IllegalArgumentException("Invalid optional, missing inner name @ " + position  +": " + pattern);
+            if (hadAll)
+                (parent == null ? ret : parent.buf).append(buf);
+            return parent;
+        }
+    }
+}