Merge pull request #215 from JLLeitschuh/feat/dependencyInjection

Feat/dependency injection

Author: JLLeitschuh

build.gradle

@@ -25,8 +25,13 @@ allprojects {
         mavenCentral()
         jcenter()
     }
+    jacoco {
+        toolVersion = "0.7.5.201505241946"
+    }
+
 
     dependencies {
+        testCompile group: 'net.jodah', name: 'concurrentunit', version: '0.4.2'
         testCompile group: 'org.hamcrest', name: 'hamcrest-all', version: '1.3'
         testCompile group: 'junit', name: 'junit', version: '4.12'
     }
@@ -58,6 +63,12 @@ allprojects {
             events "failed"
             exceptionFormat "full"
         }
+        doFirst {
+            filter.includePatterns.each {
+                include "${it.replaceAll('\\.', "\\${File.separator}")}.class"
+            }
+            filter.setIncludePatterns('*')
+        }
     }
 }
 
@@ -66,6 +77,7 @@ def os = osdetector.classifier.replace("osx", "macosx").replace("windows-x86_32"
 project(":core") {
     apply plugin: 'java'
     apply plugin: 'idea'
+    apply plugin: 'jacoco'
     apply plugin: "com.github.johnrengelman.shadow"
 
     configurations {
@@ -88,6 +100,8 @@ project(":core") {
         compile group: 'com.thoughtworks.xstream', name: 'xstream', version: '1.4.8'
         compile group: 'org.apache.commons', name: 'commons-lang3', version: '3.4'
         compile group: 'com.google.guava', name: 'guava', version: '18.0'
+        compile group: 'com.google.inject', name: 'guice', version: '4.0'
+        compile group: 'com.google.inject.extensions', name: 'guice-assistedinject', version: '4.0'
     }
 
     mainClassName = 'edu.wpi.grip.core.Main'
@@ -161,6 +175,7 @@ project(":core") {
 project(":ui") {
     apply plugin: 'java'
     apply plugin: 'idea'
+    apply plugin: 'jacoco'
     apply plugin: 'application'
     apply from: 'http://dl.bintray.com/shemnon/javafx-gradle/8.1.1/javafx.plugin'
 
@@ -173,6 +188,7 @@ project(":ui") {
         ideProvider project(path: ':core', configuration: 'compile')
         compile group: 'org.controlsfx', name: 'controlsfx', version: '8.40.10'
         testCompile files(project(':core').sourceSets.test.output.classesDir)
+        testCompile files(project(':core').sourceSets.test.output.resourcesDir)
         testCompile group: 'org.testfx', name: 'testfx-core', version: '4.0.+'
         testCompile group: 'org.testfx', name: 'testfx-junit', version: '4.0.+'
     }

core/src/main/java/edu/wpi/grip/core/Connection.java

@@ -2,91 +2,39 @@
 
 import com.google.common.eventbus.EventBus;
 import com.google.common.eventbus.Subscribe;
+import com.google.inject.Inject;
+import com.google.inject.assistedinject.Assisted;
 import com.thoughtworks.xstream.annotations.XStreamAlias;
-import edu.wpi.grip.core.events.ConnectionRemovedEvent;
-import edu.wpi.grip.core.events.SocketChangedEvent;
-import edu.wpi.grip.core.events.SourceRemovedEvent;
-import edu.wpi.grip.core.events.StepRemovedEvent;
+import edu.wpi.grip.core.events.*;
 
 import static com.google.common.base.Preconditions.checkArgument;
-import static com.google.common.base.Preconditions.checkNotNull;
 
 /**
  * A connection is a rule that causes one socket to update to always the value of another socket.
  */
 @XStreamAlias(value = "grip:Connection")
 public class Connection<T> {
+
     private final EventBus eventBus;
     private final OutputSocket<? extends T> outputSocket;
     private final InputSocket<T> inputSocket;
 
+
+    public interface Factory <T> {
+        Connection<T> create(OutputSocket<? extends T> outputSocket, InputSocket<T> inputSocket);
+    }
+
     /**
-     * @param eventBus     The Guava {@link EventBus} used by the application.
+     * @param pipeline     The pipeline to create the connection inside of.
      * @param outputSocket The socket to listen for changes in.
      * @param inputSocket  A different socket to update when a change occurs in the first.
      */
-    public Connection(EventBus eventBus, OutputSocket<? extends T> outputSocket, InputSocket<T> inputSocket) {
+    @Inject
+    Connection(EventBus eventBus, Pipeline pipeline, @Assisted OutputSocket<? extends T> outputSocket, @Assisted InputSocket<T> inputSocket) {
         this.eventBus = eventBus;
         this.outputSocket = outputSocket;
         this.inputSocket = inputSocket;
-
-        checkNotNull(inputSocket);
-        checkNotNull(outputSocket);
-        checkNotNull(eventBus);
-        checkArgument(Connection.canConnect(outputSocket, inputSocket), "Cannot connect sockets");
-
-        inputSocket.setValueOptional(outputSocket.getValue());
-
-        eventBus.register(this);
-    }
-
-    /**
-     * @return true if a connection can be made from the given output socket to the given input socket
-     */
-    @SuppressWarnings("unchecked")
-    public static boolean canConnect(Socket socket1, Socket socket2) {
-        final OutputSocket<?> outputSocket;
-        final InputSocket<?> inputSocket;
-
-        // One socket must be an input and one must be an output
-        if (socket1.getDirection() == socket2.getDirection()) {
-            return false;
-        }
-
-        if (socket1.getDirection().equals(Socket.Direction.OUTPUT)) {
-            outputSocket = (OutputSocket) socket1;
-            inputSocket = (InputSocket) socket2;
-        } else {
-            inputSocket = (InputSocket) socket1;
-            outputSocket = (OutputSocket) socket2;
-        }
-
-        final SocketHint outputHint = socket1.getSocketHint();
-        final SocketHint inputHint = socket2.getSocketHint();
-
-        // The input socket must be able to hold the type of value that the output socket contains
-        if (!inputHint.getType().isAssignableFrom(outputHint.getType())) {
-            return false;
-        }
-
-        // Input sockets can only be connected to one thing
-        if (!inputSocket.getConnections().isEmpty()) {
-            return false;
-        }
-
-        // If both sockets are in steps, the output must be before the input in the pipeline.  This prevents "backwards"
-        // connections, which both enforces a well-organized pipeline and prevents feedback loops.
-        final boolean[] backwards = {false};
-        outputSocket.getStep().ifPresent(outputStep -> inputSocket.getStep().ifPresent(inputStep -> {
-            final Pipeline pipeline = checkNotNull(inputStep.getPipeline(), "Pipeline is null");
-            if (!pipeline.isBefore(outputStep, inputStep)) {
-                backwards[0] = true;
-            }
-        }));
-
-        return !backwards[0];
-
-
+        checkArgument(pipeline.canConnect(outputSocket, inputSocket), "Cannot connect sockets");
     }
 
     public OutputSocket<? extends T> getOutputSocket() {
@@ -97,6 +45,13 @@ public InputSocket<T> getInputSocket() {
         return this.inputSocket;
     }
 
+    @Subscribe
+    public void onConnectionAdded(ConnectionAddedEvent event) {
+        if (event.getConnection().equals(this)) {
+            inputSocket.setValueOptional(outputSocket.getValue());
+        }
+    }
+
     @Subscribe
     public void onOutputChanged(SocketChangedEvent e) {
         if (e.getSocket() == outputSocket) {

core/src/main/java/edu/wpi/grip/core/GRIPCoreModule.java

@@ -0,0 +1,69 @@
+package edu.wpi.grip.core;
+
+import com.google.common.eventbus.EventBus;
+import com.google.common.eventbus.SubscriberExceptionContext;
+import com.google.inject.AbstractModule;
+import com.google.inject.TypeLiteral;
+import com.google.inject.assistedinject.FactoryModuleBuilder;
+import com.google.inject.matcher.Matchers;
+import com.google.inject.spi.InjectionListener;
+import com.google.inject.spi.TypeEncounter;
+import com.google.inject.spi.TypeListener;
+import edu.wpi.grip.core.events.UnexpectedThrowableEvent;
+import edu.wpi.grip.core.serialization.Project;
+import edu.wpi.grip.core.sources.CameraSource;
+import edu.wpi.grip.core.sources.ImageFileSource;
+import edu.wpi.grip.core.sources.MultiImageFileSource;
+import edu.wpi.grip.core.util.ExceptionWitness;
+
+/**
+ * A Guice {@link com.google.inject.Module} for GRIP's core package.  This is where instances of {@link Pipeline},
+ * {@link Palette}, {@link Project}, etc... are created.
+ */
+public class GRIPCoreModule extends AbstractModule {
+
+    private final EventBus eventBus = new EventBus(this::onSubscriberException);
+
+    public GRIPCoreModule() {
+        Thread.setDefaultUncaughtExceptionHandler(this::onThreadException);
+    }
+
+    @Override
+    protected void configure() {
+        // Register any injected object on the event bus
+        bindListener(Matchers.any(), new TypeListener() {
+            @Override
+            public <I> void hear(TypeLiteral<I> type, TypeEncounter<I> encounter) {
+                encounter.register((InjectionListener<I>) eventBus::register);
+            }
+        });
+
+        bind(EventBus.class).toInstance(eventBus);
+
+        install(new FactoryModuleBuilder().build(new TypeLiteral<Connection.Factory<Object>>() {
+        }));
+
+
+        bind(Source.SourceFactory.class).to(Source.SourceFactoryImpl.class);
+        bind(CameraSource.FrameGrabberFactory.class).to(CameraSource.FrameGrabberFactoryImpl.class);
+        install(new FactoryModuleBuilder()
+                .implement(CameraSource.class, CameraSource.class)
+                .build(CameraSource.Factory.class));
+        install(new FactoryModuleBuilder()
+                .implement(ImageFileSource.class, ImageFileSource.class)
+                .build(ImageFileSource.Factory.class));
+        install(new FactoryModuleBuilder()
+                .implement(MultiImageFileSource.class, MultiImageFileSource.class)
+                .build(MultiImageFileSource.Factory.class));
+
+        install(new FactoryModuleBuilder().build(ExceptionWitness.Factory.class));
+    }
+
+    private void onSubscriberException(Throwable exception, SubscriberExceptionContext context) {
+        eventBus.post(new UnexpectedThrowableEvent(exception, "An event subscriber threw an exception"));
+    }
+
+    private void onThreadException(Thread thread, Throwable exception) {
+        eventBus.post(new UnexpectedThrowableEvent(exception, thread + " threw an exception"));
+    }
+}

core/src/main/java/edu/wpi/grip/core/Main.java

@@ -1,10 +1,15 @@
 package edu.wpi.grip.core;
 
 import com.google.common.eventbus.EventBus;
+import com.google.common.eventbus.Subscribe;
+import com.google.inject.Guice;
+import com.google.inject.Injector;
+import edu.wpi.grip.core.events.UnexpectedThrowableEvent;
 import edu.wpi.grip.core.operations.Operations;
 import edu.wpi.grip.core.serialization.Project;
 import edu.wpi.grip.generated.CVOperations;
 
+import javax.inject.Inject;
 import java.io.File;
 import java.io.IOException;
 import java.util.logging.*;
@@ -13,7 +18,21 @@
  * Main driver class for headless mode
  */
 public class Main {
+
+    @Inject
+    private Project project;
+    @Inject
+    private EventBus eventBus;
+    @Inject
+    private Logger logger;
+
+    @SuppressWarnings("PMD.SignatureDeclareThrowsException")
     public static void main(String[] args) throws Exception {
+        final Injector injector = Guice.createInjector(new GRIPCoreModule());
+        injector.getInstance(Main.class).start(args);
+    }
+
+    public void start(String[] args) throws IOException, InterruptedException {
         if (args.length != 1) {
             System.err.println("Usage: GRIP.jar project.grip");
             return;
@@ -41,16 +60,12 @@ public static void main(String[] args) throws Exception {
             throw new IllegalStateException(exception);
         }
 
-        final String projectPath = args[0];
-
-        final EventBus eventBus = new EventBus((exception, context) -> exception.printStackTrace());
-        final Pipeline pipeline = new Pipeline(eventBus);
-        final Palette palette = new Palette(eventBus);
-        final Project project = new Project(eventBus, pipeline, palette);
 
         Operations.addOperations(eventBus);
         CVOperations.addOperations(eventBus);
 
+        final String projectPath = args[0];
+
         // Open a project from a .grip file specified on the command line
         project.open(new File(projectPath));
 
@@ -59,4 +74,15 @@ public static void main(String[] args) throws Exception {
             Thread.sleep(Integer.MAX_VALUE);
         }
     }
+
+    /**
+     * When an unexpected error happens in headless mode, print a stack trace and exit.
+     */
+    @Subscribe
+    public final void onUnexpectedThrowableEvent(UnexpectedThrowableEvent event) {
+        logger.log(Level.SEVERE, "UnexpectedThrowableEvent", event.getThrowable());
+        if (event.isFatal()) {
+            System.exit(1);
+        }
+    }
 }