[MSHADE-252] Make source shading respect package/class name excludes

Fixes MSHADE-252.

Until now, there was a naive global search + replace for mapping
'<pattern>' to '<shadedPattern>', even if the corresponding packages
are to be ignored. This works for binary JARs, but was completely
broken for source JARs.

See also my related comment in MSHADE-252:
https://issues.apache.org/jira/browse/MSHADE-252?focusedCommentId=17314377&page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel#comment-17314377

With this fix, on the one hand string replacement in source files works
for both "dotty" strings like "my.package.name.Foo" and "slashy" ones
like "/my/package/name/resource.properties". On the other hand, source
files are now being parsed '<pattern>' match by match and for each match
the excludes list will be checked and replacements only performed if the
corresponding matched package name is not on the excludes list. This is
of course slower than just a raw 'replaceAll(..)', but it produces
correct results.

Author: kriegaex

src/main/java/org/apache/maven/plugins/shade/relocation/SimpleRelocator.java

@@ -47,6 +47,10 @@ public class SimpleRelocator
 
     private final Set<String> excludes;
 
+    private final Set<String> sourcePackageExcludes = new LinkedHashSet<>();
+
+    private final Set<String> sourcePathExcludes = new LinkedHashSet<>();
+
     private final boolean rawString;
 
     public SimpleRelocator( String patt, String shadedPattern, List<String> includes, List<String> excludes )
@@ -105,6 +109,24 @@ public SimpleRelocator( String patt, String shadedPattern, List<String> includes
         {
             this.excludes.addAll( excludes );
         }
+
+        if ( !rawString && this.excludes != null )
+        {
+            // Create exclude pattern sets for sources
+            for ( String exclude : this.excludes )
+            {
+                // Excludes should be subpackages of the global pattern
+                if ( exclude.startsWith( pattern ) )
+                {
+                    sourcePackageExcludes.add( exclude.substring( pattern.length() ).replaceFirst( "[.][*]$", "" ) );
+                }
+                // Excludes should be subpackages of the global pattern
+                else if ( exclude.startsWith( pathPattern ) )
+                {
+                    sourcePathExcludes.add( exclude.substring( pathPattern.length() ).replaceFirst( "[/][*]$", "" ) );
+                }
+            }
+        }
     }
 
     private static Set<String> normalizePatterns( Collection<String> patterns )
@@ -214,7 +236,39 @@ public String applyToSourceContent( String sourceContent )
         }
         else
         {
-            return sourceContent.replaceAll( "\\b" + pattern, shadedPattern );
+            sourceContent = shadeSourceWithExcludes( sourceContent, pattern, shadedPattern, sourcePackageExcludes );
+            return shadeSourceWithExcludes( sourceContent, pathPattern, shadedPathPattern, sourcePathExcludes );
+        }
+    }
+
+    private String shadeSourceWithExcludes( String sourceContent, String patternFrom, String patternTo,
+                                            Set<String> excludedPatterns )
+    {
+        // Usually shading makes package names a bit longer, so make buffer 10% bigger than original source
+        StringBuilder shadedSourceContent = new StringBuilder( sourceContent.length() * 11 / 10 );
+        boolean isFirstSnippet = true;
+        // Make sure that search pattern starts at word boundary and we look for literal ".", not regex jokers
+        for ( String snippet : sourceContent.split( "\\b" + patternFrom.replace( ".", "[.]" ) ) )
+        {
+            boolean doExclude = false;
+            for ( String excludedPattern : excludedPatterns )
+            {
+                if ( snippet.startsWith( excludedPattern ) )
+                {
+                    doExclude = true;
+                    break;
+                }
+            }
+            if ( isFirstSnippet )
+            {
+                shadedSourceContent.append( snippet );
+                isFirstSnippet = false;
+        }
+            else
+            {
+                shadedSourceContent.append( doExclude ? patternFrom : patternTo ).append( snippet );
+            }
         }
+        return shadedSourceContent.toString();
     }
 }

src/test/java/org/apache/maven/plugins/shade/relocation/SimpleRelocatorTest.java

@@ -188,4 +188,71 @@ public void testRelocateMavenFiles()
         assertTrue( relocator.canRelocatePath( "META-INF/maven/com-foo-bar/artifactId/pom.xml" ) );
 
     }
+
+    private static final String sourceFile =
+            "package org.apache.maven.hello;\n" +
+            "\n" +
+            "import foo.bar.Bar;\n" +
+            "import zot.baz.Baz;\n" +
+            "import org.apache.maven.exclude1.Ex1;\n" +
+            "import org.apache.maven.exclude1.a.b.Ex1AB;\n" +
+            "import org.apache.maven.sub.exclude2.Ex2;\n" +
+            "import org.apache.maven.sub.exclude2.c.d.Ex2CD;\n" +
+            "import org.apache.maven.In;\n" +
+            "import org.apache.maven.e.InE;\n" +
+            "import org.apache.maven.f.g.InFG;\n" +
+            "\n" +
+            "public class MyClass {\n" +
+            "  private org.apache.maven.exclude1.x.X myX;\n" +
+            "  private org.apache.maven.h.H;\n" +
+            "\n" +
+            "  public void doSomething() {\n" +
+            "    String noRelocation = \"NoWordBoundaryXXXorg.apache.maven.In\";\n" +
+            "    String relocationPackage = \"org.apache.maven.In\";\n" +
+            "    String relocationPath = \"org/apache/maven/In\";\n" +
+            "  }\n" +
+            "}\n";
+
+    private static final String relocatedFile =
+            "package com.acme.maven.hello;\n" +
+            "\n" +
+            "import foo.bar.Bar;\n" +
+            "import zot.baz.Baz;\n" +
+            "import org.apache.maven.exclude1.Ex1;\n" +
+            "import org.apache.maven.exclude1.a.b.Ex1AB;\n" +
+            "import org.apache.maven.sub.exclude2.Ex2;\n" +
+            "import org.apache.maven.sub.exclude2.c.d.Ex2CD;\n" +
+            "import com.acme.maven.In;\n" +
+            "import com.acme.maven.e.InE;\n" +
+            "import com.acme.maven.f.g.InFG;\n" +
+            "\n" +
+            "public class MyClass {\n" +
+            "  private org.apache.maven.exclude1.x.X myX;\n" +
+            "  private com.acme.maven.h.H;\n" +
+            "\n" +
+            "  public void doSomething() {\n" +
+            "    String noRelocation = \"NoWordBoundaryXXXorg.apache.maven.In\";\n" +
+            "    String relocationPackage = \"com.acme.maven.In\";\n" +
+            "    String relocationPath = \"com/acme/maven/In\";\n" +
+            "  }\n" +
+            "}\n";
+
+    @Test
+    public void testRelocateSourceWithExcludesRaw()
+    {
+        SimpleRelocator relocator = new SimpleRelocator( "org.apache.maven", "com.acme.maven",
+                Arrays.asList( "foo.bar", "zot.baz" ),
+                Arrays.asList( "irrelevant.exclude", "org.apache.maven.exclude1", "org.apache.maven.sub.exclude2" ),
+                true );
+        assertEquals( sourceFile,  relocator.applyToSourceContent( sourceFile ) );
+    }
+
+    @Test
+    public void testRelocateSourceWithExcludes()
+    {
+        SimpleRelocator relocator = new SimpleRelocator( "org.apache.maven", "com.acme.maven",
+                Arrays.asList( "foo.bar", "zot.baz" ),
+                Arrays.asList( "irrelevant.exclude", "org.apache.maven.exclude1", "org.apache.maven.sub.exclude2" ) );
+        assertEquals( relocatedFile,  relocator.applyToSourceContent( sourceFile ) );
+    }
 }