4 mockbuilder method (#9)

* ISSUES-4 add mockbuilder

* ISSUES-4 add method mockBuilder

* ISSUES-4 add method mockBuilder

Author: h908714124

compiler/src/main/java/io/jbock/simple/processor/util/UniqueNameSet.java

@@ -34,4 +34,12 @@ public String getUniqueName(CharSequence base) {
     }
     return name;
   }
+
+  /**
+   * Adds {@code name} without any modification to the name set. Has no effect if {@code name} is
+   * already present in the set.
+   */
+  public void claim(CharSequence name) {
+    uniqueNames.add(name.toString());
+  }
 }

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

@@ -22,7 +22,6 @@
 import javax.lang.model.element.Modifier;
 import javax.lang.model.type.TypeMirror;
 import java.util.ArrayList;
-import java.util.Collection;
 import java.util.List;
 import java.util.Map;
 import java.util.function.Function;
@@ -39,19 +38,23 @@ public class ComponentImpl {
     private final ComponentElement component;
     private final Map<Key, NamedBinding> sorted;
     private final Function<Key, ParameterSpec> names;
+    private final MockBuilder mockBuilder;
+    private final Modifier[] modifiers;
 
     private ComponentImpl(
             ComponentElement component,
             Map<Key, NamedBinding> sorted,
-            Function<Key, ParameterSpec> names) {
+            Function<Key, ParameterSpec> names,
+            MockBuilder mockBuilder) {
         this.component = component;
         this.sorted = sorted;
         this.names = names;
+        this.mockBuilder = mockBuilder;
+        this.modifiers = component.element().getModifiers().stream()
+                .filter(m -> m == PUBLIC).toArray(Modifier[]::new);
     }
 
     TypeSpec generate() {
-        Modifier[] modifiers = component.element().getModifiers().stream()
-                .filter(m -> m == PUBLIC).toArray(Modifier[]::new);
         TypeSpec.Builder spec = TypeSpec.classBuilder(component.generatedClass())
                 .addModifiers(modifiers)
                 .addSuperinterface(component.element().asType());
@@ -83,22 +86,21 @@ TypeSpec generate() {
             spec.addType(createBuilderImpl(builder));
         });
         if (component.factoryElement().isEmpty() && component.builderElement().isEmpty()) {
-            spec.addMethod(generateCreateMethod(modifiers));
+            spec.addMethod(generateCreateMethod());
+            spec.addMethod(generateMockCreateMethod());
         }
+        spec.addType(mockBuilder.generate());
         spec.addAnnotation(AnnotationSpec.builder(Generated.class)
                 .addMember("value", CodeBlock.of("$S", SimpleComponentProcessor.class.getCanonicalName()))
                 .addMember("comments", CodeBlock.of("$S", "https://github.com/jbock-java/simple-component"))
                 .build());
         spec.addModifiers(FINAL);
-        spec.addMethod(generateConstructor());
-        if (sorted.values().stream().anyMatch(binding -> !(binding.binding() instanceof ParameterBinding))) {
-            spec.addMethod(generateAllParametersConstructor());
-        }
+        spec.addMethod(generateAllParametersConstructor());
         spec.addOriginatingElement(component.element());
         return spec.build();
     }
 
-    private MethodSpec generateCreateMethod(Modifier[] modifiers) {
+    private MethodSpec generateCreateMethod() {
         List<CodeBlock> constructorParameters = new ArrayList<>();
         MethodSpec.Builder method = MethodSpec.methodBuilder("create");
         for (NamedBinding namedBinding : sorted.values()) {
@@ -121,24 +123,13 @@ private MethodSpec generateCreateMethod(Modifier[] modifiers) {
                 .build();
     }
 
-    private MethodSpec generateConstructor() {
-        MethodSpec.Builder constructor = MethodSpec.constructorBuilder().addModifiers(PRIVATE);
-        for (NamedBinding namedBinding : sorted.values()) {
-            Binding b = namedBinding.binding();
-            Key key = b.key();
-            String name = namedBinding.name();
-            if (namedBinding.isComponentRequest()) {
-                FieldSpec field = FieldSpec.builder(key.typeName(), name, PRIVATE, FINAL).build();
-                constructor.addStatement("this.$N = $L", field, b.invocation(names));
-            } else if (!(b instanceof ParameterBinding)) {
-                ParameterSpec param = names.apply(key);
-                constructor.addStatement("$T $N = $L", key.typeName(), param, b.invocation(names));
-            }
-            if (b instanceof ParameterBinding) {
-                constructor.addParameter(names.apply(key));
-            }
-        }
-        return constructor.build();
+    MethodSpec generateMockCreateMethod() {
+        MethodSpec.Builder method = MethodSpec.methodBuilder("mockBuilder");
+        method.addJavadoc("Visible for testing. Do not call this method from production code.");
+        method.addStatement("return new $T()", mockBuilder.getClassName());
+        method.returns(mockBuilder.getClassName());
+        method.addModifiers(STATIC);
+        return method.build();
     }
 
     private List<FieldSpec> getFields() {
@@ -168,7 +159,6 @@ private MethodSpec generateAllParametersConstructor() {
     }
 
     private TypeSpec createFactoryImpl(FactoryElement factory) {
-        Collection<ParameterBinding> parameterBindings = component.parameterBindings();
         TypeSpec.Builder spec = TypeSpec.classBuilder(factory.generatedClass());
         spec.addModifiers(PRIVATE, STATIC, FINAL);
         spec.addSuperinterface(factory.element().asType());
@@ -178,58 +168,85 @@ private TypeSpec createFactoryImpl(FactoryElement factory) {
         method.addModifiers(abstractMethod.getModifiers().stream()
                 .filter(m -> m == PUBLIC || m == PROTECTED).collect(Collectors.toList()));
         method.returns(TypeName.get(component.element().asType()));
-        method.addStatement("return new $T($L)", component.generatedClass(), parameterBindings.stream()
-                .map(b -> CodeBlock.of("$N", names.apply(b.key())))
-                .collect(CodeBlock.joining(", ")));
-        for (ParameterBinding b : parameterBindings) {
-            method.addParameter(names.apply(b.key()));
+        List<CodeBlock> constructorParameters = new ArrayList<>();
+        for (NamedBinding namedBinding : sorted.values()) {
+            Binding b = namedBinding.binding();
+            Key key = b.key();
+            CodeBlock invocation = b.invocation(names);
+            ParameterSpec param = names.apply(key);
+            if (namedBinding.isComponentRequest()) {
+                constructorParameters.add(CodeBlock.of("$N", names.apply(key)));
+            }
+            if (b instanceof ParameterBinding) {
+                method.addParameter(names.apply(b.key()));
+            } else {
+                method.addStatement("$T $N = $L", key.typeName(), param, invocation);
+            }
         }
+        method.addStatement("return new $T($L)", component.generatedClass(), constructorParameters.stream()
+                .collect(CodeBlock.joining(", ")));
         spec.addMethod(method.build());
         return spec.build();
     }
 
     private TypeSpec createBuilderImpl(BuilderElement builder) {
-        Collection<ParameterBinding> parameterBindings = component.parameterBindings();
         TypeMirror builderType = builder.element().asType();
         TypeSpec.Builder spec = TypeSpec.classBuilder(builder.generatedClass());
-        for (ParameterBinding b : parameterBindings) {
-            spec.addField(FieldSpec.builder(b.key().typeName(), names.apply(b.key()).name).build());
-            MethodSpec.Builder setterMethod = MethodSpec.methodBuilder(b.element().getSimpleName().toString());
-            setterMethod.addAnnotation(Override.class);
-            setterMethod.addParameter(names.apply(b.key()));
-            setterMethod.addStatement("this.$N = $N", names.apply(b.key()), names.apply(b.key()));
-            setterMethod.addStatement("return this");
-            setterMethod.returns(TypeName.get(builderType));
-            setterMethod.addModifiers(b.element().getModifiers().stream()
-                    .filter(m -> m == PUBLIC || m == PROTECTED).collect(Collectors.toList()));
-            spec.addMethod(setterMethod.build());
+        MethodSpec.Builder buildMethod = MethodSpec.methodBuilder(builder.buildMethod().getSimpleName().toString());
+        List<CodeBlock> constructorParameters = new ArrayList<>();
+        for (NamedBinding namedBinding : sorted.values()) {
+            Binding b = namedBinding.binding();
+            Key key = b.key();
+            CodeBlock invocation = b.invocation(names);
+            ParameterSpec param = names.apply(key);
+            if (namedBinding.isComponentRequest()) {
+                constructorParameters.add(CodeBlock.of("$N", names.apply(key)));
+            }
+            if (b instanceof ParameterBinding) {
+                spec.addField(FieldSpec.builder(b.key().typeName(), names.apply(b.key()).name).build());
+                MethodSpec.Builder setterMethod = MethodSpec.methodBuilder(b.element().getSimpleName().toString());
+                setterMethod.addAnnotation(Override.class);
+                setterMethod.addParameter(names.apply(b.key()));
+                setterMethod.addStatement("this.$N = $N", names.apply(b.key()), names.apply(b.key()));
+                setterMethod.addStatement("return this");
+                setterMethod.returns(TypeName.get(builderType));
+                setterMethod.addModifiers(b.element().getModifiers().stream()
+                        .filter(m -> m == PUBLIC || m == PROTECTED).collect(Collectors.toList()));
+                spec.addMethod(setterMethod.build());
+            } else {
+                buildMethod.addStatement("$T $N = $L", key.typeName(), param, invocation);
+            }
         }
         spec.addModifiers(PRIVATE, STATIC, FINAL);
         spec.addSuperinterface(builderType);
-        MethodSpec.Builder buildMethod = MethodSpec.methodBuilder(builder.buildMethod().getSimpleName().toString());
         buildMethod.addAnnotation(Override.class);
         buildMethod.addModifiers(builder.buildMethod().getModifiers().stream()
                 .filter(m -> m == PUBLIC || m == PROTECTED).collect(Collectors.toList()));
         buildMethod.returns(TypeName.get(component.element().asType()));
-        buildMethod.addStatement("return new $T($L)", component.generatedClass(), parameterBindings.stream()
-                .map(b -> CodeBlock.of("$N", names.apply(b.key())))
+        buildMethod.addStatement("return new $T($L)", component.generatedClass(), constructorParameters.stream()
                 .collect(CodeBlock.joining(", ")));
         spec.addMethod(buildMethod.build());
         return spec.build();
     }
 
     public static final class Factory {
         private final ComponentElement component;
+        private final MockBuilder.Factory mockBuilderFactory;
 
         @Inject
-        public Factory(ComponentElement component) {
+        public Factory(ComponentElement component, MockBuilder.Factory mockBuilderFactory) {
             this.component = component;
+            this.mockBuilderFactory = mockBuilderFactory;
         }
 
         ComponentImpl create(
                 Map<Key, NamedBinding> sorted,
                 Function<Key, ParameterSpec> names) {
-            return new ComponentImpl(component, sorted, names);
+            return new ComponentImpl(
+                    component,
+                    sorted,
+                    names,
+                    mockBuilderFactory.create(sorted, names));
         }
     }
 }

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

@@ -35,10 +35,12 @@ public TypeSpec generate(List<Binding> bindings) {
 
     private Map<Key, NamedBinding> addNames(List<Binding> bindings) {
         UniqueNameSet uniqueNameSet = new UniqueNameSet();
+        uniqueNameSet.claim("build");
         Map<Key, NamedBinding> result = new LinkedHashMap<>();
         for (Binding b : bindings) {
             String name = uniqueNameSet.getUniqueName(validJavaName(b.suggestedVariableName()));
-            result.put(b.key(), new NamedBinding(b, name, component.isComponentRequest(b)));
+            String auxName = uniqueNameSet.getUniqueName(name + "_isSet");
+            result.put(b.key(), new NamedBinding(b, name, auxName, component.isComponentRequest(b)));
         }
         return result;
     }

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

@@ -0,0 +1,141 @@
+package io.jbock.simple.processor.writing;
+
+import io.jbock.javapoet.ClassName;
+import io.jbock.javapoet.CodeBlock;
+import io.jbock.javapoet.FieldSpec;
+import io.jbock.javapoet.MethodSpec;
+import io.jbock.javapoet.ParameterSpec;
+import io.jbock.javapoet.TypeName;
+import io.jbock.javapoet.TypeSpec;
+import io.jbock.simple.Inject;
+import io.jbock.simple.processor.binding.Binding;
+import io.jbock.simple.processor.binding.ComponentElement;
+import io.jbock.simple.processor.binding.Key;
+import io.jbock.simple.processor.binding.ParameterBinding;
+
+import javax.lang.model.element.Modifier;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.function.Function;
+
+import static javax.lang.model.element.Modifier.FINAL;
+import static javax.lang.model.element.Modifier.PRIVATE;
+import static javax.lang.model.element.Modifier.PUBLIC;
+import static javax.lang.model.element.Modifier.STATIC;
+
+public class MockBuilder {
+
+    private final ComponentElement component;
+    private final Map<Key, NamedBinding> sorted;
+    private final Function<Key, ParameterSpec> names;
+    private final Modifier[] modifiers;
+
+    MockBuilder(
+            ComponentElement component,
+            Map<Key, NamedBinding> sorted,
+            Function<Key, ParameterSpec> names) {
+        this.component = component;
+        this.sorted = sorted;
+        this.names = names;
+        this.modifiers = component.element().getModifiers().stream()
+                .filter(m -> m == PUBLIC).toArray(Modifier[]::new);
+    }
+
+    TypeSpec generate() {
+        TypeSpec.Builder spec = TypeSpec.classBuilder(getClassName())
+                .addModifiers(modifiers)
+                .addModifiers(STATIC, FINAL);
+        spec.addMethod(buildMethod());
+        spec.addFields(getFields());
+        spec.addMethods(getMethods());
+        return spec.build();
+    }
+
+    ClassName getClassName() {
+        return component.generatedClass().nestedClass("MockBuilder");
+    }
+
+    private MethodSpec buildMethod() {
+        List<CodeBlock> constructorParameters = new ArrayList<>();
+        MethodSpec.Builder method = MethodSpec.methodBuilder("build");
+        for (NamedBinding namedBinding : sorted.values()) {
+            Binding b = namedBinding.binding();
+            Key key = b.key();
+            CodeBlock invocation = b.invocation(names);
+            ParameterSpec param = names.apply(key);
+            if (namedBinding.isComponentRequest()) {
+                constructorParameters.add(CodeBlock.of("$N", names.apply(key)));
+            }
+            if (namedBinding.binding() instanceof ParameterBinding) {
+                method.addParameter(names.apply(b.key()));
+            } else if (!key.typeName().isPrimitive()) {
+                method.addStatement("$1T $2N = this.$2N != null ? this.$2N : $3L", key.typeName(), param, invocation);
+            } else {
+                FieldSpec auxField = FieldSpec.builder(TypeName.BOOLEAN, namedBinding.auxName(), PRIVATE).build();
+                method.addStatement("$1T $2N = this.$3N ? this.$2N : $4L", key.typeName(), param, auxField, invocation);
+            }
+        }
+        return method
+                .addModifiers(modifiers)
+                .returns(TypeName.get(component.element().asType()))
+                .addStatement("return new $T($L)",
+                        component.generatedClass(),
+                        constructorParameters.stream().collect(CodeBlock.joining(", ")))
+                .build();
+    }
+
+    private List<FieldSpec> getFields() {
+        List<FieldSpec> fields = new ArrayList<>();
+        for (NamedBinding namedBinding : sorted.values()) {
+            if (namedBinding.binding() instanceof ParameterBinding) {
+                continue;
+            }
+            TypeName type = namedBinding.binding().key().typeName();
+            FieldSpec field = FieldSpec.builder(type, namedBinding.name(), PRIVATE).build();
+            fields.add(field);
+            if (namedBinding.binding().key().typeName().isPrimitive()) {
+                FieldSpec auxField = FieldSpec.builder(TypeName.BOOLEAN, namedBinding.auxName(), PRIVATE).build();
+                fields.add(auxField);
+            }
+        }
+        return fields;
+    }
+
+    private List<MethodSpec> getMethods() {
+        List<MethodSpec> methods = new ArrayList<>();
+        for (NamedBinding namedBinding : sorted.values()) {
+            if (namedBinding.binding() instanceof ParameterBinding) {
+                continue;
+            }
+            Binding b = namedBinding.binding();
+            Key key = b.key();
+            ParameterSpec param = names.apply(key);
+            MethodSpec.Builder method = MethodSpec.methodBuilder(param.name)
+                    .addModifiers(modifiers)
+                    .addParameter(param)
+                    .addStatement("this.$1N = $1N", param);
+            if (namedBinding.binding().key().typeName().isPrimitive()) {
+                FieldSpec auxField = FieldSpec.builder(TypeName.BOOLEAN, namedBinding.auxName(), PRIVATE).build();
+                method.addStatement("this.$N = $L", auxField, true);
+            }
+            methods.add(method.build());
+        }
+        return methods;
+    }
+
+    public static final class Factory {
+        private final ComponentElement component;
+
+        @Inject
+        public Factory(ComponentElement component) {
+            this.component = component;
+        }
+
+        MockBuilder create(
+                Map<Key, NamedBinding> sorted,
+                Function<Key, ParameterSpec> names) {
+            return new MockBuilder(component, sorted, names);
+        }
+    }
+}