Merge branch '1.0' into wip/integration

DefaultExternalHooks and WrappedClassFileManager are moved to xsbt.compile.

Author: eed3si9n

src/main/contraband-java/xsbti/compile/IncOptions.java

@@ -59,16 +59,7 @@ public static java.util.Map<String, String> defaultExtra() {
         return new java.util.HashMap<String, String>();
     }
     public static ExternalHooks defaultExternal() {
-        return new ExternalHooks() {
-            @Override
-            public java.util.Optional<Lookup> externalLookup() {
-                return java.util.Optional.empty();
-            }
-            @Override
-            public java.util.Optional<ClassFileManager> externalClassFileManager() {
-                return java.util.Optional.empty();
-            }
-        };
+        return new DefaultExternalHooks(java.util.Optional.empty(), java.util.Optional.empty());
     }
     public static boolean defaultLogRecompileOnMacro() {
         return true;

src/main/contraband/incremental.json

@@ -230,16 +230,7 @@
         "    return new java.util.HashMap<String, String>();",
         "}",
         "public static ExternalHooks defaultExternal() {",
-        "    return new ExternalHooks() {",
-        "        @Override",
-        "        public java.util.Optional<Lookup> externalLookup() {",
-        "            return java.util.Optional.empty();",
-        "        }",
-        "        @Override",
-        "        public java.util.Optional<ClassFileManager> externalClassFileManager() {",
-        "            return java.util.Optional.empty();",
-        "        }",
-        "    };",
+        "    return new DefaultExternalHooks(java.util.Optional.empty(), java.util.Optional.empty());",
         "}",
         "public static boolean defaultLogRecompileOnMacro() {",
         "    return true;",

src/main/java/xsbti/compile/DefaultExternalHooks.java

@@ -0,0 +1,48 @@
+/*
+ * Zinc - The incremental compiler for Scala.
+ * Copyright 2011 - 2017, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * This software is released under the terms written in LICENSE.
+ */
+
+package xsbti.compile;
+
+import java.io.File;
+import java.util.Optional;
+import java.util.Set;
+
+public class DefaultExternalHooks implements ExternalHooks {
+    private Optional<ExternalHooks.Lookup> lookup = Optional.empty();
+    private Optional<ClassFileManager> classFileManager = Optional.empty();
+
+    public DefaultExternalHooks(Optional<ExternalHooks.Lookup> lookup, Optional<ClassFileManager> classFileManager) {
+        this.lookup = lookup;
+        this.classFileManager = classFileManager;
+    }
+
+    @Override
+    public Optional<Lookup> getExternalLookup() {
+        return lookup;
+    }
+
+    @Override
+    public Optional<ClassFileManager> getExternalClassFileManager() {
+        return classFileManager;
+    }
+
+    @Override
+    public ExternalHooks withExternalClassFileManager(ClassFileManager externalClassFileManager) {
+        Optional<ClassFileManager> currentManager = this.getExternalClassFileManager();
+        Optional<ClassFileManager> mixedManager = currentManager;
+        if (currentManager.isPresent()) {
+            Optional<ClassFileManager> external = Optional.of(externalClassFileManager);
+            mixedManager = Optional.of(WrappedClassFileManager.of(currentManager.get(), external));
+        }
+        return new DefaultExternalHooks(this.getExternalLookup(), mixedManager);
+    }
+
+    @Override
+    public ExternalHooks withExternalLookup(Lookup externalLookup) {
+        return new DefaultExternalHooks(Optional.of(externalLookup), this.getExternalClassFileManager());
+    }
+}

src/main/java/xsbti/compile/ExternalHooks.java

@@ -12,14 +12,14 @@
 import java.util.Set;
 
 /**
- * Define hooks that can be user-defined to modify the behaviour of
+ * Defines hooks that can be user-defined to modify the behaviour of
  * internal components of the incremental compiler.
  */
 public interface ExternalHooks {
     /**
-     * Define an interface for a lookup mechanism.
+     * Defines an interface for a lookup mechanism.
      */
-    public static interface Lookup {
+    interface Lookup {
 
         /**
          * Used to provide information from external tools into sbt (e.g. IDEs)
@@ -54,17 +54,36 @@ public static interface Lookup {
     }
 
     /**
-     * Return the implementation of a lookup mechanism to be used instead of
+     * Returns the implementation of a lookup mechanism to be used instead of
      * the internal lookup provided by the default implementation.
      */
-    Optional<Lookup> externalLookup();
+    Optional<Lookup> getExternalLookup();
 
     /**
-     * Return the implementation of a {@link ClassFileManager} to be used
+     * Returns the implementation of a {@link ClassFileManager} to be used
      * alongside the internal manager provided by the default implementation.
      * <p>
      * This class file manager is run after the internal
      * {@link ClassFileManager} defined in {@link IncOptions}.
      */
-    Optional<ClassFileManager> externalClassFileManager();
+    Optional<ClassFileManager> getExternalClassFileManager();
+
+    /**
+     * Returns an instance of hooks that executes the external passed class file manager.
+     *
+     * If several class file manager are passed, they are aggregated and their execution happens
+     * in the order of invocations of this method.
+     *
+     * @return An instance of {@link ExternalHooks} with the aggregated external class file manager.
+     */
+    ExternalHooks withExternalClassFileManager(ClassFileManager externalClassFileManager);
+
+    /**
+     * Returns an instance of hooks with one lookup.
+     *
+     * If used several times, only the last lookup instance will be used.
+     *
+     * @return An instance of {@link ExternalHooks} with the specified lookup.
+     */
+    ExternalHooks withExternalLookup(Lookup externalLookup);
 }

src/main/java/xsbti/compile/WrappedClassFileManager.java

@@ -0,0 +1,63 @@
+/*
+ * Zinc - The incremental compiler for Scala.
+ * Copyright 2011 - 2017, Lightbend, Inc.
+ * Copyright 2008 - 2010, Mark Harrah
+ * This software is released under the terms written in LICENSE.
+ */
+
+package xsbti.compile;
+
+import java.io.File;
+import java.util.Optional;
+
+/**
+ * Defines a classfile manager that composes the operation of two classfile manager,
+ * one being the internal classfile manager (the one used by the compiler) and the
+ * other one being the external classfile manager (a customizable, build tool-defined
+ * class file manager to control which class files should be notified/removed/generated
+ * aside from the ones covered by the internal classfile manager).
+ *
+ * @param internal Compiler classfile manager.
+ * @param external Build tool (or external) classfile manager the complements the internal one.
+ */
+public class WrappedClassFileManager implements ClassFileManager {
+  private ClassFileManager internal;
+  private Optional<ClassFileManager> external;
+  
+  public static WrappedClassFileManager of(ClassFileManager internal, Optional<ClassFileManager> external) {
+      return new WrappedClassFileManager(internal, external);
+  }
+
+  protected WrappedClassFileManager(ClassFileManager internal,
+                                    Optional<ClassFileManager> external) {
+    this.internal = internal;
+    this.external = external;
+  }
+
+  @Override
+  public void delete(File[] classes) {
+    // Avoid Java 8 syntax to accommodate Scala 2.10
+    if (external.isPresent()) {
+      external.get().delete(classes);
+    }
+    internal.delete(classes);
+  }
+
+  @Override
+  public void complete(boolean success) {
+    // Avoid Java 8 syntax to accommodate Scala 2.10
+    if (external.isPresent()) {
+      external.get().complete(success);
+    }
+    internal.complete(success);
+  }
+
+  @Override
+  public void generated(File[] classes) {
+    // Avoid Java 8 syntax to accommodate Scala 2.10
+    if (external.isPresent()) {
+      external.get().generated(classes);
+    }
+    internal.generated(classes);
+  }
+}