#835 Remove all injector classes from AuthMe, update installer tasks

src/test/java/tools/checktestmocks/CheckTestMocks.java

@@ -3,18 +3,16 @@ package tools.checktestmocks;
 import com.google.common.base.Function;
 import com.google.common.collect.Collections2;
 import com.google.common.collect.Sets;
-import fr.xephi.authme.initialization.Injection;
-import fr.xephi.authme.initialization.InjectionHelper;
 import fr.xephi.authme.util.StringUtils;
 import org.mockito.Mock;
 import tools.utils.AutoToolTask;
+import tools.utils.InjectorUtils;
 import tools.utils.ToolsConstants;
 
 import java.io.File;
 import java.lang.reflect.Field;
 import java.util.ArrayList;
 import java.util.Collection;
-import java.util.Collections;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Scanner;
@@ -76,8 +74,10 @@ public class CheckTestMocks implements AutoToolTask {
         Class<?> realClass = returnRealClass(testClass);
         if (realClass != null) {
             Set<Class<?>> mockFields = getMocks(testClass);
-            Set<Class<?>> injectFields = getRealClassDependencies(realClass);
-            if (!injectFields.containsAll(mockFields)) {
+            Set<Class<?>> injectFields = InjectorUtils.getDependencies(realClass);
+            if (injectFields == null) {
+                addErrorEntry(testClass, "Could not find instantiation method");
+            } else if (!injectFields.containsAll(mockFields)) {
                 addErrorEntry(testClass, "Error - Found the following mocks absent as @Inject: "
                     + formatClassList(Sets.difference(mockFields, injectFields)));
             } else if (!mockFields.containsAll(injectFields)) {
@@ -137,13 +137,6 @@ public class CheckTestMocks implements AutoToolTask {
         }
     }
 
-    private static Set<Class<?>> getRealClassDependencies(Class<?> realClass) {
-        Injection<?> injection = InjectionHelper.getInjection(realClass);
-        return injection == null
-            ? Collections.<Class<?>>emptySet()
-            : Sets.<Class<?>>newHashSet(injection.getDependencies());
-    }
-
     private static boolean isTestClassWithMocks(Class<?> clazz) {
         for (Field field : clazz.getDeclaredFields()) {
             if (field.isAnnotationPresent(Mock.class)) {

src/test/java/tools/dependencygraph/DrawDependency.java

@@ -1,16 +1,17 @@
 package tools.dependencygraph;
 
+import ch.jalu.injector.handlers.instantiation.DependencyDescription;
+import ch.jalu.injector.handlers.instantiation.Instantiation;
 import com.google.common.collect.HashMultimap;
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.Multimap;
 import fr.xephi.authme.command.ExecutableCommand;
 import fr.xephi.authme.converter.Converter;
-import fr.xephi.authme.initialization.Injection;
-import fr.xephi.authme.initialization.InjectionHelper;
 import fr.xephi.authme.process.AsynchronousProcess;
 import fr.xephi.authme.process.SynchronousProcess;
 import fr.xephi.authme.security.crypts.EncryptionMethod;
 import org.bukkit.event.Listener;
+import tools.utils.InjectorUtils;
 import tools.utils.ToolTask;
 import tools.utils.ToolsConstants;
 
@@ -143,8 +144,8 @@ public class DrawDependency implements ToolTask {
     }
 
     private List<String> getDependencies(Class<?> clazz) {
-        Injection<?> injection = InjectionHelper.getInjection(clazz);
-        return injection == null ? null : formatInjectionDependencies(injection);
+        Instantiation<?> instantiation = InjectorUtils.getInstantiationMethod(clazz);
+        return instantiation == null ? null : formatInjectionDependencies(instantiation);
     }
 
     /**
@@ -155,9 +156,15 @@ public class DrawDependency implements ToolTask {
      * @param injection the injection whose dependencies should be formatted
      * @return list of dependencies in a friendly format
      */
-    private List<String> formatInjectionDependencies(Injection<?> injection) {
-        Class<?>[] dependencies = injection.getDependencies();
-        Class<?>[] annotations = injection.getDependencyAnnotations();
+    private List<String> formatInjectionDependencies(Instantiation<?> injection) {
+        List<? extends DependencyDescription> descriptions = injection.getDependencies();
+        final int totalDependencies = descriptions.size();
+        Class<?>[] dependencies = new Class<?>[totalDependencies];
+        Class<?>[] annotations = new Class<?>[totalDependencies];
+        for (int i = 0; i < descriptions.size(); ++i) {
+            dependencies[i] = descriptions.get(i).getType();
+            annotations[i] = null; // FIXME #835 descriptions.get(i).getAnnotations();
+        }
 
         List<String> result = new ArrayList<>(dependencies.length);
         for (int i = 0; i < dependencies.length; ++i) {

src/test/java/tools/utils/InjectorUtils.java

@@ -0,0 +1,55 @@
+package tools.utils;
+
+import ch.jalu.injector.InjectorBuilder;
+import ch.jalu.injector.handlers.instantiation.DependencyDescription;
+import ch.jalu.injector.handlers.instantiation.Instantiation;
+import ch.jalu.injector.handlers.instantiation.InstantiationProvider;
+
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+/**
+ * Utility for operations with the injector.
+ */
+public final class InjectorUtils {
+
+    private InjectorUtils() {
+    }
+
+    /**
+     * Returns a class' dependencies as determined by the injector.
+     *
+     * @param clazz the class to process
+     * @return the class' dependencies, or null if no instantiation method found
+     */
+    public static Set<Class<?>> getDependencies(Class<?> clazz) {
+        Instantiation<?> instantiation = getInstantiationMethod(clazz);
+        if (instantiation == null) {
+            return null;
+        }
+        Set<Class<?>> dependencies = new HashSet<>();
+        for (DependencyDescription description : instantiation.getDependencies()) {
+            dependencies.add(description.getType());
+        }
+        return dependencies;
+    }
+
+    /**
+     * Returns the instantiation method for the given class.
+     *
+     * @param clazz the class to process
+     * @return the instantiation method for the class, or null if none applicable
+     */
+    public static Instantiation<?> getInstantiationMethod(Class<?> clazz) {
+        List<InstantiationProvider> providers = InjectorBuilder.createInstantiationProviders();
+        for (InstantiationProvider provider : providers) {
+            Instantiation<?> instantiation = provider.get(clazz);
+            if (instantiation != null) {
+                return instantiation;
+            }
+        }
+        return null;
+    }
+
+}