Migrating Maven transformer to Gradle.

I originally wrote this in its own plugin which attached itself to the shadow plugin. It's better to bundle the transformer into the shadow plugin inself instead of my own orthoginal plugin.

https://issues.apache.org/jira/browse/LOG4J2-673
https://github.com/paul-nelson-baker/gradle-shaded-log4j2-cachefile-transformer/blob/master/src/main/java/io/paulbaker/gradle/shadow/transform/Log4j2PluginsCacheFileTransformer.java
https://github.com/edwgiz/maven-shaded-log4j-transformer/blob/master/src/main/java/com/github/edwgiz/mavenShadePlugin/log4j2CacheTransformer/PluginsCacheFileTransformer.java

Author: nikole-dunixi

gradle/dependencies.gradle

@@ -10,6 +10,7 @@ dependencies {
     compile 'commons-io:commons-io:2.5'
     compile 'org.apache.ant:ant:1.9.7'
     compile 'org.codehaus.plexus:plexus-utils:3.0.24'
+    compile "org.apache.logging.log4j:log4j-core:2.11.0"
 
     testCompile("org.spockframework:spock-core:1.0-groovy-2.4") {
         exclude module: 'groovy-all'

src/main/groovy/com/github/jengelman/gradle/plugins/shadow/transformers/Log4j2PluginsCacheFileTransformer.groovy

@@ -0,0 +1,118 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License") you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package com.github.jengelman.gradle.plugins.shadow.transformers
+
+import com.github.jengelman.gradle.plugins.shadow.ShadowStats
+import com.github.jengelman.gradle.plugins.shadow.relocation.RelocateClassContext
+import com.github.jengelman.gradle.plugins.shadow.relocation.Relocator
+import org.apache.commons.io.IOUtils
+import org.apache.commons.io.output.CloseShieldOutputStream
+import org.apache.logging.log4j.core.config.plugins.processor.PluginCache
+import org.apache.logging.log4j.core.config.plugins.processor.PluginEntry
+import org.apache.tools.zip.ZipOutputStream
+import org.gradle.api.file.FileTreeElement
+
+import java.util.zip.ZipEntry
+
+import static org.apache.logging.log4j.core.config.plugins.processor.PluginProcessor.PLUGIN_CACHE_FILE;
+
+/**
+ * Modified from the maven equivalent to work with gradle
+ *
+ * @author Paul Nelson Baker
+ * @see <a href="https://www.linkedin.com/in/paul-n-baker/">LinkedIn</a>
+ * @see <a href="https://github.com/paul-nelson-baker/">GitHub</a>
+ * @see <a href="https://github.com/edwgiz/maven-shaded-log4j-transformer">edwgiz/maven-shaded-log4j-transformer</a>
+ * @see <a href="https://github.com/edwgiz/maven-shaded-log4j-transformer/blob/master/src/main/java/com/github/edwgiz/mavenShadePlugin/log4j2CacheTransformer/PluginsCacheFileTransformer.java">PluginsCacheFileTransformer.java</a>
+ */
+class Log4j2PluginsCacheFileTransformer implements Transformer {
+
+    private final List<File> temporaryFiles;
+    private final List<Relocator> relocators;
+
+    public Log4j2PluginsCacheFileTransformer() {
+        temporaryFiles = new ArrayList<>();
+        relocators = new ArrayList<>();
+    }
+
+    @Override
+    boolean canTransformResource(FileTreeElement element) {
+        return PLUGIN_CACHE_FILE == element.name
+    }
+
+    @Override
+    void transform(TransformerContext context) {
+        def inputStream = context.is
+        def temporaryFile = File.createTempFile("Log4j2Plugins", ".dat")
+        temporaryFile.deleteOnExit()
+        temporaryFiles.add(temporaryFile)
+        IOUtils.copy(inputStream, new FileOutputStream(temporaryFile))
+        def contextRelocators = context.relocators
+        if (contextRelocators != null) {
+            this.relocators.addAll(contextRelocators)
+        }
+    }
+
+    @Override
+    boolean hasTransformedResource() {
+        // This functionality matches the original plugin, however, I'm not clear what
+        // the exact logic is. From what I can tell temporaryFiles should be never be empty
+        // if anything has been performed.
+        def hasTransformedMultipleFiles = temporaryFiles.size() > 1
+        def hasAtLeastOneFileAndRelocator = !temporaryFiles.isEmpty() && !relocators.isEmpty()
+        def hasTransformedResources = hasTransformedMultipleFiles || hasAtLeastOneFileAndRelocator
+        return hasTransformedResources
+    }
+
+    @Override
+    void modifyOutputStream(ZipOutputStream jos) {
+        PluginCache pluginCache = new PluginCache()
+        pluginCache.loadCacheFiles(getUrlEnumeration())
+        relocatePlugins(pluginCache)
+        zipOutputStream.putNextEntry(new ZipEntry(PLUGIN_CACHE_FILE))
+        pluginCache.writeCache(new CloseShieldOutputStream(zipOutputStream))
+        temporaryFiles.clear()
+    }
+
+    private Enumeration<URL> getUrlEnumeration() {
+        def urls = temporaryFiles.collect({ it.toURL() }).asList()
+        return Collections.enumeration(urls)
+    }
+
+    private void relocatePlugins(PluginCache pluginCache) {
+        for (Map<String, PluginEntry> currentMap : pluginCache.getAllCategories().values()) {
+            pluginEntryLoop:
+            for (PluginEntry currentPluginEntry : currentMap.values()) {
+                String className = currentPluginEntry.getClassName();
+                RelocateClassContext relocateClassContext = new RelocateClassContext(className, new ShadowStats());
+                for (Relocator currentRelocator : relocators) {
+                    // If we have a relocator that can relocate our current entry...
+                    boolean canRelocateClass = currentRelocator.canRelocateClass(relocateClassContext);
+                    if (canRelocateClass) {
+                        // Then we perform that relocation and update the plugin entry to reflect the new value.
+                        String relocatedClassName = currentRelocator.relocateClass(relocateClassContext);
+                        currentPluginEntry.setClassName(relocatedClassName);
+                        continue pluginEntryLoop;
+                    }
+                }
+            }
+        }
+    }
+}