Fixed provide order mapping in injector (1.8.2)

 - made more descriptive error messages

Author: Michal-python

.gitignore

@@ -1,2 +1,4 @@
 /target
 .idea
+server.yaml
+*/dependency-reduced-pom.xml

client/pom.xml

@@ -6,7 +6,7 @@
     <parent>
         <groupId>cat.michal.catbase</groupId>
         <artifactId>CatBase</artifactId>
-        <version>1.8.1-fix</version>
+        <version>1.8.2</version>
     </parent>
 
     <groupId>cat.michal.catbase.client</groupId>

common/pom.xml

@@ -6,7 +6,7 @@
     <parent>
         <groupId>cat.michal.catbase</groupId>
         <artifactId>CatBase</artifactId>
-        <version>1.8.1-fix</version>
+        <version>1.8.2</version>
     </parent>
 
     <groupId>cat.michal.catbase.common</groupId>

dependencyInjection/pom.xml

@@ -6,7 +6,7 @@
     <parent>
         <groupId>cat.michal.catbase</groupId>
         <artifactId>CatBase</artifactId>
-        <version>1.8.1-fix</version>
+        <version>1.8.2</version>
     </parent>
 
     <groupId>cat.michal.catbase.injector</groupId>

dependencyInjection/src/main/java/cat/michal/catbase/injector/CatBaseInjector.java

@@ -8,6 +8,7 @@
 import java.lang.reflect.Method;
 import java.lang.reflect.Modifier;
 import java.util.*;
+import java.util.stream.Collectors;
 
 public class CatBaseInjector implements Injector {
     private final List<Dependency<?>> dependencies;
@@ -79,7 +80,7 @@ public void destroy() {
     @SuppressWarnings("unchecked")
     public <T> T createInstance(Class<T> clazz) {
         if(clazz.isEnum()) {
-            throw new InjectorException("Enums are not allowed");
+            throw new InjectorException("Enums (" + clazz.getSimpleName() + ") are not supported");
         }
 
         if(clazz.isInterface() || Modifier.isAbstract(clazz.getModifiers())) {
@@ -88,7 +89,7 @@ public <T> T createInstance(Class<T> clazz) {
                     .map(classElement -> (Class<? extends T>) classElement)
                     .toList();
             if(implementations.isEmpty()) {
-                throw new InjectorException("No implementation found for abstraction layer " + clazz.getName());
+                throw new InjectorException("No matching dependency implementation for " + clazz.getName());
             }
 
             //if only one implementation - no need to look for primary implementations
@@ -99,10 +100,10 @@ public <T> T createInstance(Class<T> clazz) {
                     .filter(injectable -> injectable.isAnnotationPresent(Primary.class))
                     .toList();
             if(primaryImplementations.size() > 1) {
-                throw new InjectorException("More than one primary implementation of abstraction layer " + clazz.getName());
+                throw new InjectorException("More than one primary implementation for dependency " + clazz.getName());
             }
             if(primaryImplementations.isEmpty()) {
-                throw new InjectorException("No primary implementation found for abstraction layer " + clazz.getName());
+                throw new InjectorException("No primary implementation found for dependency " + clazz.getName());
             }
             return createInstance(primaryImplementations.get(0));
         }
@@ -149,24 +150,46 @@ public void registerInjectables() {
                             .filter(method -> method.isAnnotationPresent(Provide.class))
                             .forEach(method -> {
                                 if(method.getReturnType().isAnnotationPresent(Component.class)) {
-                                    throw new InjectorException("Provide methods annotated with @Component are not allowed");
+                                    throw new InjectorException("Provide method types annotated with @Component are not allowed");
                                 }
                                 registerDependency(method.getReturnType(), method, clazz);
                             });
                 });
 
+        //check for nested dependencies for provided instances
+        dependencies.stream().filter(dependency -> dependency.getProvideMethod() != null).forEach(dependency -> {
+           Dependency<?> containingDependency = dependencies.stream()
+                    .filter(containingClass -> containingClass.getClazz().equals(dependency.getContainingClass()))
+                    .findFirst()
+                    .orElseThrow(() -> new InjectorException("Dependency " + dependency.getContainingClass().getName() + " not found"));
+           dependency.addDependency(containingDependency);
+        });
         //check for nested dependencies
         dependencies.stream()
                 // filter only dependencies that are needed for the dependency tree
                 .filter(dependency -> dependency.getProvideMethod() == null && dependency.getInstance() == null)
-                .forEach(dependency -> Arrays.stream(dependency.getClazz().getDeclaredFields())
-                .filter(field -> !field.isAnnotationPresent(Exclude.class))
-                .forEach(field -> {
-                    Class<?> fieldType = field.getType();
-                    dependencies.stream()
-                            .filter(dep -> fieldType.isAssignableFrom(dep.getClazz()))
-                            .findFirst().ifPresent(dependency::addDependency);
-                }));
+                .forEach(dependency -> {
+                    Constructor<?> validConstructor = getConstructor(dependency);
+                    Arrays.stream(validConstructor.getParameterTypes())
+                                    .forEach(type -> {
+                                        dependencies.stream()
+                                                .filter(dep -> type.isAssignableFrom(dep.getClazz()))
+                                                .findFirst()
+                                                .ifPresent(dependency::addDependency);
+                                    });
+
+
+
+                    Arrays.stream(dependency.getClazz().getDeclaredFields())
+                            .filter(field -> field.isAnnotationPresent(Inject.class))
+                            .forEach(field -> {
+                                Class<?> fieldType = field.getType();
+                                dependencies.stream()
+                                        .filter(dep -> fieldType.isAssignableFrom(dep.getClazz()))
+                                        .findFirst()
+                                        .ifPresent(dependency::addDependency);
+                            });
+                });
 
         //check for circular dependencies
         Set<Dependency<?>> visited = new HashSet<>();
@@ -207,6 +230,19 @@ public void registerInjectables() {
         });
     }
 
+    @SuppressWarnings("unchecked")
+    private <T> Constructor<T> getConstructor(Dependency<T> dependency) {
+        return (Constructor<T>) Arrays.stream(dependency.getClazz().getConstructors())
+                .filter(constructorElement -> constructorElement.getParameterTypes().length == 0
+                        || Arrays.stream(constructorElement.getParameterTypes())
+                        .allMatch(element ->
+                                containsByClass(element) || (element.isInterface() && element.isAnnotationPresent(Component.class))
+                        )
+                )
+                .findAny()
+                .orElseThrow(() -> new InjectorException("No constructors with valid parameters found for " + dependency.getClazz().getName()));
+    }
+
     private void initializeDependency(Dependency<?> dependency, List<Dependency<?>> sortedDependencies) {
         if (!sortedDependencies.contains(dependency)) {
             dependency.getDepends().forEach(dep -> initializeDependency(dep, sortedDependencies));
@@ -216,7 +252,7 @@ private void initializeDependency(Dependency<?> dependency, List<Dependency<?>>
 
     private void checkCircularDependency(Dependency<?> dependency, Set<Dependency<?>> visited, Set<Dependency<?>> stack) {
         if (stack.contains(dependency)) {
-            throw new InjectorException("Circular dependency detected involving " + dependency.getClazz());
+            throw new InjectorException("Circular dependency detected involving " + stack.stream().map(clazz -> clazz.getClass().getSimpleName()).collect(Collectors.joining()));
         }
         if (!visited.contains(dependency)) {
             visited.add(dependency);
@@ -245,15 +281,15 @@ public <T> void injectField(T instance) {
                                     return dependency.getClazz().equals(field.getType()) || (!injectName.isEmpty() && injectName.equals(dependency.getName()));
                                 })
                                 .findFirst()
-                                .orElseThrow(() -> new InjectorException("Could not find injectable for field " + field.getName()))
+                                .orElseThrow(() -> new InjectorException("Could not find dependency of type + " + field.getType().getSimpleName() + " for field " + instance.getClass().getSimpleName() + "." + field.getName()))
                                 .getInstance();
                         if(toInject.getClass().equals(instance.getClass())) {
-                            throw new InjectorException("Could not inject field " + field.getName() + " into itself");
+                            throw new InjectorException("Could not inject field " + instance.getClass().getSimpleName() + "." + field.getName() + " into itself");
                         }
                         field.setAccessible(true);
                         field.set(instance, toInject);
                     } catch (IllegalAccessException e) {
-                        throw new InjectorException("Could not inject field " + field.getName(), e);
+                        throw new InjectorException("Could not inject field " + instance.getClass().getSimpleName() + "." + field.getName(), e);
                     }
                 });
     }
@@ -299,7 +335,7 @@ public <T> T getInstance(Class<T> clazz) {
         return ((T) dependencies.stream()
                 .filter(dependency -> dependency.getClazz().equals(clazz))
                 .findFirst()
-                .orElseThrow(() -> new InjectorException("Could not find injectable for class " + clazz.getName()))
+                .orElseThrow(() -> new InjectorException("Could not find dependency of type " + clazz.getName()))
                 .getInstance());
     }
 
@@ -308,29 +344,23 @@ public void clearInjectables() {
         this.dependencies.clear();
     }
 
-
-    @SuppressWarnings("unchecked")
     private <T> T instantiate(Dependency<T> dependency) {
-        Constructor<T> constructor = (Constructor<T>) Arrays.stream(dependency.getClazz().getConstructors())
-                .filter(constructorElement -> constructorElement.getParameterTypes().length == 0 || Arrays.stream(constructorElement.getParameterTypes())
-                        .allMatch(element -> containsByClass(element) || (element.isInterface() && element.isAnnotationPresent(Component.class)))
-                )
-                .findAny()
-                .orElseThrow(() -> new InjectorException("No matching constructor found for class " + dependency.getClazz().getName()));
+        Constructor<T> constructor = getConstructor(dependency);
+
         try {
             if(constructor.getParameterCount() == 0) {
                 return constructor.newInstance();
             }
 
             return constructor.newInstance(Arrays.stream(constructor.getParameterTypes()).map(this::getInstance).toArray());
         } catch (Exception exception) {
-            throw new InjectorException("Could not instantiate class " + dependency.getClazz().getName(), exception);
+            throw new InjectorException("Could not create instance of class " + dependency.getClazz().getName(), exception);
         }
     }
 
     private <T> void registerDependency(Class<T> clazz, Method provideMethod, Class<?> containingClass) {
         if(this.containsByClass(clazz)) {
-            throw new InjectorException("Class " + clazz.getName() + " is already registered");
+            throw new InjectorException("Duplicate dependency for type " + clazz.getName());
         }
 
         String injectableName;
@@ -342,7 +372,7 @@ private <T> void registerDependency(Class<T> clazz, Method provideMethod, Class<
         }
 
         if(containsByName(injectableName)) {
-            throw new InjectorException("Class with component name " + injectableName + " is already registered");
+            throw new InjectorException("Duplicate component name " + injectableName);
         }
         Dependency<T> dependency = new Dependency<>(injectableName, clazz, null, provideMethod, containingClass);
         this.dependencies.add(dependency);

dependencyInjection/src/main/java/cat/michal/catbase/injector/Dependency.java

@@ -1,8 +1,8 @@
 package cat.michal.catbase.injector;
 
 import java.lang.reflect.Method;
-import java.util.ArrayList;
-import java.util.List;
+import java.util.HashSet;
+import java.util.Set;
 
 /**
  *
@@ -17,7 +17,7 @@ public class Dependency<T> {
 
     private final String name;
     private final Class<T> clazz;
-    private final List<Dependency<?>> depends;
+    private final Set<Dependency<?>> depends;
     private T instance;
     private final Method provideMethod;
     private final Class<?> containingClass;
@@ -27,7 +27,7 @@ public Dependency(String name, Class<T> clazz, T instance, Method provideMethod,
         this.clazz = clazz;
         this.instance = instance;
         this.provideMethod = provideMethod;
-        this.depends = new ArrayList<>();
+        this.depends = new HashSet<>();
         this.containingClass = containingClass;
     }
 
@@ -47,7 +47,7 @@ public <D> void addDependency(Dependency<D> dependency) {
         this.depends.add(dependency);
     }
 
-    public List<Dependency<?>> getDepends() {
+    public Set<Dependency<?>> getDepends() {
         return depends;
     }
 
@@ -63,4 +63,12 @@ public String getName() {
     public void setInstance(Object instance) {
         this.instance = (T) instance;
     }
+
+    @Override
+    public String toString() {
+        return "Dependency{" +
+                "class=" + clazz.getSimpleName() +
+                ", name='" + name + '\'' +
+                '}';
+    }
 }

dependencyInjection/src/test/java/cat/michal/catbase/injector/MixedTest.java

@@ -0,0 +1,31 @@
+package cat.michal.catbase.injector;
+
+import cat.michal.catbase.injector.mixedTest.MapperDependant;
+import cat.michal.catbase.injector.mixedTest.OuterDependency;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.TestInstance;
+
+import java.util.List;
+import java.util.logging.Logger;
+
+@TestInstance(TestInstance.Lifecycle.PER_CLASS)
+public class MixedTest {
+    private CatBaseInjector injector;
+
+    @BeforeAll
+    void setup() {
+        this.injector = new CatBaseInjector(List.of(
+                CatBaseInjector.createExternalDependency(String::toUpperCase, OuterDependency.class),
+                CatBaseInjector.createExternalDependency(Logger.getLogger("Logger"), Logger.class)
+        ),
+                "cat.michal.catbase.injector.mixedTest");
+    }
+
+    @Test
+    void testMixed() {
+        Assertions.assertEquals("VALUE", this.injector.getInstance(MapperDependant.class).invoke());
+    }
+
+}

dependencyInjection/src/test/java/cat/michal/catbase/injector/mixedTest/Mapper.java

@@ -0,0 +1,5 @@
+package cat.michal.catbase.injector.mixedTest;
+
+public interface Mapper {
+    String map(String value);
+}

dependencyInjection/src/test/java/cat/michal/catbase/injector/mixedTest/MapperDependant.java

@@ -0,0 +1,15 @@
+package cat.michal.catbase.injector.mixedTest;
+
+import cat.michal.catbase.injector.annotations.Component;
+
+@Component
+public class MapperDependant {
+    private final Mapper mapper;
+    public MapperDependant(Mapper mapper) {
+        this.mapper = mapper;
+    }
+
+    public String invoke() {
+        return mapper.map("value");
+    }
+}

dependencyInjection/src/test/java/cat/michal/catbase/injector/mixedTest/MapperFactory.java

@@ -0,0 +1,25 @@
+package cat.michal.catbase.injector.mixedTest;
+
+import cat.michal.catbase.injector.annotations.Component;
+import cat.michal.catbase.injector.annotations.Provide;
+
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+@Component
+public class MapperFactory {
+    private Logger logger;
+
+    public MapperFactory(Logger logger) {
+        this.logger = logger;
+    }
+
+    @Provide
+    @SuppressWarnings("unused")
+    public Mapper createMapper(OuterDependency outerDependency) {
+        return value -> {
+            logger.log(Level.INFO, "test");
+            return outerDependency.consume(value);
+        };
+    }
+}