Merge pull request #210 from skapral/issue/208

[#208] Added excludePackage configuration parameter to atom-maven-plugin

Author: skapral

atom-basis/src/main/java/com/pragmaticobjects/oo/atom/codegen/AtomizerMain.java

@@ -25,6 +25,7 @@
 package com.pragmaticobjects.oo.atom.codegen;
 
 import com.pragmaticobjects.oo.atom.anno.NotAtom;
+import com.pragmaticobjects.oo.atom.codegen.cn.CnFromPath;
 import com.pragmaticobjects.oo.atom.codegen.cp.CpFromString;
 import com.pragmaticobjects.oo.atom.codegen.stage.AggroInstrumentationStage;
 import com.pragmaticobjects.oo.atom.codegen.stage.CopyAtomAnnotations;
@@ -64,6 +65,9 @@ public static final void main(String... args) throws Exception {
                 System.getProperty("java.class.path")
             ),
             workingDirectory,
+            new CnFromPath(
+                workingDirectory
+            ),
             stage,
             new CopyAtomAnnotations()
         ).apply();

atom-basis/src/main/java/com/pragmaticobjects/oo/atom/codegen/cn/CnExcludingPackages.java

@@ -0,0 +1,46 @@
+package com.pragmaticobjects.oo.atom.codegen.cn;
+
+import io.vavr.collection.List;
+
+/**
+ * Class names list, excluding classes from certain packages
+ *
+ * @author Kapralov Sergey
+ */
+public class CnExcludingPackages implements ClassNames {
+    private final ClassNames delegate;
+    private final List<String> packages;
+
+    /**
+     * Ctor.
+     *
+     * @param delegate Source class names
+     * @param packages Packages to exclude
+     */
+    public CnExcludingPackages(ClassNames delegate, List<String> packages) {
+        this.delegate = delegate;
+        this.packages = packages;
+    }
+
+    /**
+     * Ctor.
+     *
+     * @param delegate Source class names
+     * @param packages Packages to exclude
+     */
+    public CnExcludingPackages(ClassNames delegate, String... packages) {
+        this(
+            delegate,
+            List.of(packages)
+        );
+    }
+
+    @Override
+    public final List<String> classNames() {
+        List<String> names = this.delegate.classNames();
+        for(String pkg : packages) {
+            names = names.filter(cn -> !cn.startsWith(pkg + "."));
+        }
+        return names;
+    }
+}

atom-basis/src/main/java/com/pragmaticobjects/oo/atom/instrumentation/ApplyStages.java

@@ -24,7 +24,6 @@
 package com.pragmaticobjects.oo.atom.instrumentation;
 
 import com.pragmaticobjects.oo.atom.codegen.cn.ClassNames;
-import com.pragmaticobjects.oo.atom.codegen.cn.CnFromPath;
 import com.pragmaticobjects.oo.atom.codegen.cp.ClassPath;
 import com.pragmaticobjects.oo.atom.codegen.cp.CpCombined;
 import com.pragmaticobjects.oo.atom.codegen.cp.CpExplicit;
@@ -42,18 +41,22 @@ public class ApplyStages implements Instrumentation {
     private final ClassPath classPath;
     private final Path workingDirectory;
     private final List<Stage> stages;
+    private final ClassNames classNames;
+
 
     /**
      * Ctor.
      *
      * @param classPath {@link ClassPath}
      * @param workingDirectory Working directory - root of the location where instrumented classes located.
      * @param stages Stages to apply.
+     * @param classNames Class names
      */
-    public ApplyStages(final ClassPath classPath, final Path workingDirectory, final List<Stage> stages) {
+    public ApplyStages(ClassPath classPath, Path workingDirectory, ClassNames classNames, List<Stage> stages) {
         this.classPath = classPath;
         this.workingDirectory = workingDirectory;
         this.stages = stages;
+        this.classNames = classNames;
     }
 
     /**
@@ -62,11 +65,13 @@ public ApplyStages(final ClassPath classPath, final Path workingDirectory, final
      * @param classPath {@link ClassPath}
      * @param workingDirectory Working directory - root of the location where instrumented classes located.
      * @param stages Stages to apply.
+     * @param classNames Class names
      */
-    public ApplyStages(final ClassPath classPath, final Path workingDirectory, final Stage... stages) {
+    public ApplyStages(final ClassPath classPath, final Path workingDirectory, ClassNames classNames, final Stage... stages) {
         this(
             classPath,
             workingDirectory,
+            classNames,
             List.of(stages)
         );
     }
@@ -79,9 +84,6 @@ public final void apply() {
                 workingDirectory
             )
         );
-        final ClassNames classNames = new CnFromPath(
-            workingDirectory
-        );
         for(Stage stage : stages) {
             stage.apply(classPath, classNames, workingDirectory);
         }

atom-basis/src/test/java/com/pragmaticobjects/oo/atom/codegen/cn/CnExcludingPackagesTest.java

@@ -0,0 +1,59 @@
+package com.pragmaticobjects.oo.atom.codegen.cn;
+
+import com.pragmaticobjects.oo.atom.tests.TestCase;
+import com.pragmaticobjects.oo.atom.tests.TestsSuite;
+
+/**
+ * Tests suite for {@link CnExcludingPackages}
+ *
+ * @author Kapralov Sergey
+ */
+class CnExcludingPackagesTest extends TestsSuite {
+    /**
+     * Ctor.
+     */
+    public CnExcludingPackagesTest() {
+        super(
+            new TestCase(
+                "Excluding nothing",
+                new AssertClassNamesContainCertainNames(
+                    new CnExcludingPackages(
+                        new CnExplicit(
+                            "com.package1.Foo",
+                            "com.package2.Bar"
+                        )
+                    ),
+                    "com.package1.Foo",
+                    "com.package2.Bar"
+                )
+            ),
+            new TestCase(
+                "Excluding a single package",
+                new AssertClassNamesContainCertainNames(
+                    new CnExcludingPackages(
+                        new CnExplicit(
+                            "com.package1.Foo",
+                            "com.package2.Bar"
+                        ),
+                        "com.package1"
+                    ),
+                    "com.package2.Bar"
+                )
+            ),
+            new TestCase(
+                "Excluding non-existing package",
+                new AssertClassNamesContainCertainNames(
+                    new CnExcludingPackages(
+                        new CnExplicit(
+                            "com.package1.Foo",
+                            "com.package2.Bar"
+                        ),
+                        "com.package"
+                    ),
+                    "com.package1.Foo",
+                    "com.package2.Bar"
+                )
+            )
+        );
+    }
+}

atom-maven-plugin/src/main/java/com/pragmaticobjects/oo/atom/maven/BaseMojo.java

@@ -1,5 +1,7 @@
 package com.pragmaticobjects.oo.atom.maven;
 
+import com.pragmaticobjects.oo.atom.codegen.cn.CnExcludingPackages;
+import com.pragmaticobjects.oo.atom.codegen.cn.CnFromPath;
 import com.pragmaticobjects.oo.atom.codegen.cp.ClassPath;
 import com.pragmaticobjects.oo.atom.codegen.cp.CpFromString;
 import com.pragmaticobjects.oo.atom.codegen.stage.Stage;
@@ -13,6 +15,7 @@
 
 import java.io.File;
 import java.nio.file.Path;
+import java.util.Optional;
 import java.util.stream.Collectors;
 
 /**
@@ -25,6 +28,8 @@ public abstract class BaseMojo extends AbstractMojo {
     private MavenProject project;
     @Parameter(defaultValue = "false", required = true, readonly = true)
     private boolean instrumentPomProjects;
+    @Parameter
+    private String[] excludePackages;
 
     protected final void doInstrumentation(Stage stage, Path workingDirectory) throws MojoExecutionException, MojoFailureException {
         if(!project.getPackaging().equals("pom") || instrumentPomProjects) {
@@ -34,9 +39,15 @@ protected final void doInstrumentation(Stage stage, Path workingDirectory) throw
                     .collect(Collectors.joining(":"));
             ClassPath cp = new CpFromString(classPath);
             new ApplyStages(
-                    cp,
-                    workingDirectory,
-                    stage
+                cp,
+                workingDirectory,
+                new CnExcludingPackages(
+                    new CnFromPath(
+                        workingDirectory
+                    ),
+                    Optional.ofNullable(excludePackages).orElse(new String[] {})
+                ),
+                stage
             ).apply();
         }
     }