Collision logging, Transformers for JSON and Standard Files

.gitignore

@@ -17,3 +17,4 @@ src/docs/.vuepress/dist/
 jd-gui.cfg
 bin/
 .vscode/
+/package-lock.json

gradle/dependencies.gradle

@@ -4,6 +4,7 @@ dependencies {
     shadow 'org.codehaus.groovy:groovy-backports-compat23:3.0.8'
 
     implementation 'org.jdom:jdom2:2.0.6.1'
+    implementation 'com.google.code.gson:gson:2.10.1'
     implementation 'org.ow2.asm:asm:9.4'
     implementation 'org.ow2.asm:asm-commons:9.4'
     implementation 'commons-io:commons-io:2.11.0'

src/docs/changes/README.md

@@ -3,6 +3,7 @@
 ## v8.1.1 (2023-03-20)
 
 **NOTE: ** As of this version, the Github repository has migrated to the `main` branch as the default branch for releases.
+* Added collision logging from chapmajs.
 
 [Release Notes](https://github.com/johnrengelman/shadow/releases/tag/8.1.1)
 

src/main/groovy/com/github/jengelman/gradle/plugins/shadow/tasks/ShadowCopyAction.groovy

@@ -5,8 +5,10 @@ import com.github.jengelman.gradle.plugins.shadow.impl.RelocatorRemapper
 import com.github.jengelman.gradle.plugins.shadow.internal.UnusedTracker
 import com.github.jengelman.gradle.plugins.shadow.internal.ZipCompressor
 import com.github.jengelman.gradle.plugins.shadow.relocation.Relocator
+import com.github.jengelman.gradle.plugins.shadow.transformers.StandardFilesMergeTransformer
 import com.github.jengelman.gradle.plugins.shadow.transformers.Transformer
 import com.github.jengelman.gradle.plugins.shadow.transformers.TransformerContext
+import groovy.util.logging.Log
 import groovy.util.logging.Slf4j
 import org.apache.commons.io.FilenameUtils
 import org.apache.commons.io.IOUtils
@@ -15,6 +17,7 @@ import org.apache.tools.zip.Zip64RequiredException
 import org.apache.tools.zip.ZipEntry
 import org.apache.tools.zip.ZipFile
 import org.apache.tools.zip.ZipOutputStream
+import org.codehaus.groovy.transform.LogASTTransformation
 import org.gradle.api.Action
 import org.gradle.api.GradleException
 import org.gradle.api.UncheckedIOException
@@ -37,13 +40,18 @@ import org.objectweb.asm.ClassReader
 import org.objectweb.asm.ClassVisitor
 import org.objectweb.asm.ClassWriter
 import org.objectweb.asm.commons.ClassRemapper
+import org.slf4j.Logger
+import org.slf4j.LoggerFactory
 
+import javax.annotation.Nullable
 import java.util.zip.ZipException
 
-@Slf4j
+
 class ShadowCopyAction implements CopyAction {
     static final long CONSTANT_TIME_FOR_ZIP_ENTRIES = (new GregorianCalendar(1980, 1, 1, 0, 0, 0)).getTimeInMillis()
 
+    final static Logger log = LoggerFactory.getLogger(ShadowCopyAction.class);
+
     private final File zipFile
     private final ZipCompressor compressor
     private final DocumentationRegistry documentationRegistry
@@ -57,9 +65,9 @@ class ShadowCopyAction implements CopyAction {
     private final UnusedTracker unusedTracker
 
     ShadowCopyAction(File zipFile, ZipCompressor compressor, DocumentationRegistry documentationRegistry,
-                            String encoding, List<Transformer> transformers, List<Relocator> relocators,
-                            PatternSet patternSet, ShadowStats stats,
-                            boolean preserveFileTimestamps, boolean minimizeJar, UnusedTracker unusedTracker) {
+                     String encoding, List<Transformer> transformers, List<Relocator> relocators,
+                     PatternSet patternSet, ShadowStats stats,
+                     boolean preserveFileTimestamps, boolean minimizeJar, UnusedTracker unusedTracker) {
 
         this.zipFile = zipFile
         this.compressor = compressor
@@ -148,7 +156,7 @@ class ShadowCopyAction implements CopyAction {
     private static <T extends Closeable> void withResource(T resource, Action<? super T> action) {
         try {
             action.execute(resource)
-        } catch(Throwable t) {
+        } catch (Throwable t) {
             try {
                 resource.close()
             } catch (IOException ignored) {
@@ -197,25 +205,50 @@ class ShadowCopyAction implements CopyAction {
         private final Set<String> unused
         private final ShadowStats stats
 
-        private Set<String> visitedFiles = new HashSet<String>()
+        private Map<String, Map> visitedFiles = new HashMap<>()
 
         StreamAction(ZipOutputStream zipOutStr, String encoding, List<Transformer> transformers,
-                            List<Relocator> relocators, PatternSet patternSet, Set<String> unused,
-                            ShadowStats stats) {
+                     List<Relocator> relocators, PatternSet patternSet, Set<String> unused,
+                     ShadowStats stats) {
             this.zipOutStr = zipOutStr
             this.transformers = transformers
             this.relocators = relocators
             this.remapper = new RelocatorRemapper(relocators, stats)
             this.patternSet = patternSet
             this.unused = unused
             this.stats = stats
-            if(encoding != null) {
+            if (encoding != null) {
                 this.zipOutStr.setEncoding(encoding)
             }
         }
 
-        private boolean recordVisit(RelativePath path) {
-            return visitedFiles.add(path.pathString)
+        /**
+         * Record visit and return true if visited for the first time.
+         *
+         * @param path Visited path.
+         * @param size Size.
+         * @param originJar JAR it originated from.
+         * @return True if wasn't visited already.
+         */
+        private boolean recordVisit(String path, long size, @Nullable RelativePath originJar) {
+            if (visitedFiles.containsKey(path)) {
+                return false
+            }
+
+            if (originJar == null) {
+                originJar = new RelativePath(false)
+            }
+
+            visitedFiles.put(path.toString(), [size: size, originJar: originJar])
+            return true
+        }
+
+        private boolean recordVisit(path) {
+            return recordVisit(path.toString(), 0, null)
+        }
+
+        private boolean recordVisit(FileCopyDetails fileCopyDetails) {
+            return recordVisit(fileCopyDetails.relativePath.toString(), fileCopyDetails.size, null)
         }
 
         @Override
@@ -238,7 +271,7 @@ class ShadowCopyAction implements CopyAction {
                     } else if (isClass && !isUnused(fileDetails.path)) {
                         remapClass(fileDetails)
                     }
-                    recordVisit(fileDetails.relativePath)
+                    recordVisit(fileDetails)
                 } catch (Exception e) {
                     throw new GradleException(String.format("Could not add %s to ZIP '%s'.", fileDetails, zipFile), e)
                 }
@@ -260,7 +293,7 @@ class ShadowCopyAction implements CopyAction {
                 }
                 filteredArchiveElements.each { ArchiveFileTreeElement archiveElement ->
                     if (archiveElement.relativePath.file) {
-                        visitArchiveFile(archiveElement, archive)
+                        visitArchiveFile(archiveElement, archive, fileDetails)
                     }
                 }
             } finally {
@@ -270,21 +303,50 @@ class ShadowCopyAction implements CopyAction {
         }
 
         private void visitArchiveDirectory(RelativeArchivePath archiveDir) {
-            if (recordVisit(archiveDir)) {
+            if (recordVisit(archiveDir.toString())) {
                 zipOutStr.putNextEntry(archiveDir.entry)
                 zipOutStr.closeEntry()
             }
         }
 
-        private void visitArchiveFile(ArchiveFileTreeElement archiveFile, ZipFile archive) {
-            def archiveFilePath = archiveFile.relativePath
+        private void visitArchiveFile(ArchiveFileTreeElement archiveFile, ZipFile archive, FileCopyDetails fileDetails) {
+            RelativeArchivePath archiveFilePath = archiveFile.relativePath
+            long archiveFileSize = archiveFile.size
+
             if (archiveFile.classFile || !isTransformable(archiveFile)) {
-                if (recordVisit(archiveFilePath) && !isUnused(archiveFilePath.entry.name)) {
+                String path = archiveFilePath.toString()
+                if (recordVisit(path, archiveFileSize, archiveFilePath) && !isUnused(archiveFilePath.entry.name)) {
                     if (!remapper.hasRelocators() || !archiveFile.classFile) {
                         copyArchiveEntry(archiveFilePath, archive)
                     } else {
                         remapClass(archiveFilePath, archive)
                     }
+                } else {
+                    def archiveFileInVisitedFiles = visitedFiles.get(path)
+                    if (archiveFileInVisitedFiles && (archiveFileInVisitedFiles.size != fileDetails.size)) {
+                        // Give of only a debug-level warning for this file:
+                        final String lowLevelWarningFile = "META-INF/MANIFEST.MF"
+
+                        final logDebug = (String msg) -> { log.debug(msg) }
+                        final logWarn = (String msg) -> { log.warn(msg) }
+
+                        final Closure logger
+                        if (archiveFilePath.toString() == lowLevelWarningFile) {
+                            logger = logDebug
+                        } else {
+                            logger = logWarn
+                        }
+                        logger("IGNORING ${archiveFilePath} from ${fileDetails.relativePath}," +
+                                " size is different (${fileDetails.size} vs ${archiveFileInVisitedFiles.size})")
+                        if (archiveFileInVisitedFiles.originJar) {
+                            logger("\t--> origin JAR was ${archiveFileInVisitedFiles.originJar}")
+                        } else {
+                            logger("\t--> file originated from project sourcecode")
+                        }
+                        if (new StandardFilesMergeTransformer().canTransformResource(archiveFile)) {
+                            logger("\t--> Recommended transformer is " + StandardFilesMergeTransformer.class.name)
+                        }
+                    }
                 }
             } else {
                 transform(archiveFile, archive)
@@ -377,6 +439,12 @@ class ShadowCopyAction implements CopyAction {
             }
         }
 
+        /**
+         * Copy archive entry.
+         *
+         * @param archiveFile Source archive entry.
+         * @param archive Source archive.
+         */
         private void copyArchiveEntry(RelativeArchivePath archiveFile, ZipFile archive) {
             String mappedPath = remapper.map(archiveFile.entry.name)
             ZipEntry entry = new ZipEntry(mappedPath)
@@ -410,19 +478,20 @@ class ShadowCopyAction implements CopyAction {
         }
 
         private void transform(ArchiveFileTreeElement element, ZipFile archive) {
-            transformAndClose(element, archive.getInputStream(element.relativePath.entry))
+            transformAndClose(element, archive, archive.getInputStream(element.relativePath.entry))
         }
 
         private void transform(FileCopyDetails details) {
-            transformAndClose(details, details.file.newInputStream())
+            transformAndClose(details, null, details.file.newInputStream())
         }
 
-        private void transformAndClose(FileTreeElement element, InputStream is) {
+        private void transformAndClose(FileTreeElement element, @Nullable ZipFile archive, InputStream is) {
             try {
                 String mappedPath = remapper.map(element.relativePath.pathString)
                 transformers.find { it.canTransformResource(element) }.transform(
                         TransformerContext.builder()
                                 .path(mappedPath)
+                                .origin(archive)
                                 .is(is)
                                 .relocators(relocators)
                                 .stats(stats)