refactoring

Author: h908714124

compiler/src/main/java/io/jbock/simple/processor/ContextComponent.java

@@ -1,12 +1,10 @@
 package io.jbock.simple.processor;
 
 import io.jbock.simple.Component;
-import io.jbock.simple.Provides;
 import io.jbock.simple.processor.binding.ComponentElement;
 import io.jbock.simple.processor.binding.InjectBindingFactory;
 import io.jbock.simple.processor.binding.KeyFactory;
 import io.jbock.simple.processor.graph.TopologicalSorter;
-import io.jbock.simple.processor.util.SafeElements;
 import io.jbock.simple.processor.util.TypeTool;
 import io.jbock.simple.processor.writing.Generator;
 

compiler/src/main/java/io/jbock/simple/processor/step/ComponentStep.java

@@ -91,8 +91,8 @@ private void process(TypeElement typeElement) {
         ContextComponent componentComponent = ContextComponent.create(
                 component, tool, injectBindingFactory, keyFactory);
         Generator generator = componentComponent.generator();
-        List<Binding> sorted = componentComponent.topologicalSorter().sortedBindings();
-        TypeSpec typeSpec = generator.generate(sorted);
+        List<Binding> bindings = componentComponent.topologicalSorter().sortedBindings();
+        TypeSpec typeSpec = generator.generate(bindings);
         specWriter.write(component.generatedClass(), typeSpec);
     }
 }

compiler/src/main/java/io/jbock/simple/processor/writing/ComponentImpl.java

@@ -19,7 +19,6 @@
 import javax.annotation.processing.Generated;
 import javax.lang.model.element.ExecutableElement;
 import java.util.Collection;
-import java.util.HashMap;
 import java.util.Map;
 import java.util.function.Function;
 import java.util.stream.Collectors;
@@ -33,22 +32,21 @@
 public class ComponentImpl {
 
     private final ComponentElement component;
+    private final Map<Key, NamedBinding> sorted;
+    private final Function<Key, ParameterSpec> names;
 
-    @Inject
-    public ComponentImpl(ComponentElement component) {
+    private ComponentImpl(
+            ComponentElement component,
+            Map<Key, NamedBinding> sorted,
+            Function<Key, ParameterSpec> names) {
         this.component = component;
+        this.sorted = sorted;
+        this.names = names;
     }
 
-    TypeSpec generate(Map<Key, NamedBinding> sorted) {
+    TypeSpec generate() {
         TypeSpec.Builder spec = TypeSpec.classBuilder(component.generatedClass()).addSuperinterface(component.element().asType());
         MethodSpec.Builder constructor = MethodSpec.constructorBuilder().addModifiers(PRIVATE);
-        Map<Key, ParameterSpec> parameterCache = new HashMap<>();
-        Function<Key, ParameterSpec> names = key -> {
-            return parameterCache.computeIfAbsent(key, k -> {
-                String name = sorted.get(k).name();
-                return ParameterSpec.builder(k.typeName(), name).build();
-            });
-        };
         for (NamedBinding namedBinding : sorted.values()) {
             Binding b = namedBinding.binding();
             Key key = b.key();
@@ -121,4 +119,19 @@ private TypeSpec createFactory(
         spec.addMethod(method.build());
         return spec.build();
     }
+
+    public static final class Factory {
+        private final ComponentElement component;
+
+        @Inject
+        public Factory(ComponentElement component) {
+            this.component = component;
+        }
+
+        ComponentImpl create(
+                Map<Key, NamedBinding> sorted,
+                Function<Key, ParameterSpec> names) {
+            return new ComponentImpl(component, sorted, names);
+        }
+    }
 }

compiler/src/main/java/io/jbock/simple/processor/writing/Generator.java

@@ -1,5 +1,6 @@
 package io.jbock.simple.processor.writing;
 
+import io.jbock.javapoet.ParameterSpec;
 import io.jbock.javapoet.TypeSpec;
 import io.jbock.simple.Inject;
 import io.jbock.simple.processor.binding.Binding;
@@ -8,37 +9,51 @@
 import io.jbock.simple.processor.util.UniqueNameSet;
 
 import javax.lang.model.SourceVersion;
+import java.util.HashMap;
 import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.function.Function;
 
 public class Generator {
 
-    private final ComponentImpl componentImpl;
+    private final ComponentImpl.Factory componentImpl;
     private final ComponentElement component;
 
     @Inject
     public Generator(
-            ComponentImpl componentImpl,
+            ComponentImpl.Factory componentImpl,
             ComponentElement component) {
         this.componentImpl = componentImpl;
         this.component = component;
     }
 
-    public TypeSpec generate(List<Binding> sorted) {
-        return componentImpl.generate(addNames(sorted));
+    public TypeSpec generate(List<Binding> bindings) {
+        Map<Key, NamedBinding> sorted = addNames(bindings);
+        return componentImpl.create(sorted, createNames(sorted)).generate();
     }
 
-    Map<Key, NamedBinding> addNames(List<Binding> sorted) {
+    private Map<Key, NamedBinding> addNames(List<Binding> bindings) {
         UniqueNameSet uniqueNameSet = new UniqueNameSet();
         Map<Key, NamedBinding> result = new LinkedHashMap<>();
-        for (Binding b : sorted) {
+        for (Binding b : bindings) {
             String name = uniqueNameSet.getUniqueName(validJavaName(b.suggestedVariableName()));
             result.put(b.key(), new NamedBinding(b, name, component.isComponentRequest(b)));
         }
         return result;
     }
 
+    private static Function<Key, ParameterSpec> createNames(
+            Map<Key, NamedBinding> sorted) {
+        Map<Key, ParameterSpec> cache = new HashMap<>();
+        return key -> {
+            return cache.computeIfAbsent(key, k -> {
+                String name = sorted.get(k).name();
+                return ParameterSpec.builder(k.typeName(), name).build();
+            });
+        };
+    }
+
     private static String validJavaName(String name) {
         if (SourceVersion.isIdentifier(name)) {
             return protectAgainstKeywords(name);