add builder annotation

Author: h908714124

compiler/src/main/java/io/jbock/simple/processor/binding/BuilderElement.java

@@ -0,0 +1,94 @@
+package io.jbock.simple.processor.binding;
+
+import io.jbock.javapoet.ClassName;
+import io.jbock.simple.processor.util.ValidationFailure;
+
+import javax.lang.model.element.Element;
+import javax.lang.model.element.ExecutableElement;
+import javax.lang.model.element.TypeElement;
+import javax.lang.model.util.ElementFilter;
+import java.util.List;
+import java.util.Objects;
+import java.util.function.Supplier;
+import java.util.stream.Collectors;
+
+import static io.jbock.simple.processor.util.Suppliers.memoize;
+import static javax.lang.model.element.Modifier.STATIC;
+
+public class BuilderElement {
+
+    private final TypeElement element;
+    private final ClassName parentClass;
+    private final KeyFactory keyFactory;
+
+    private final Supplier<ExecutableElement> buildMethod = memoize(() -> {
+        Element componentElement = element().getEnclosingElement();
+        List<ExecutableElement> methods = ElementFilter.methodsIn(element().getEnclosedElements()).stream()
+                .filter(m -> !m.getModifiers().contains(STATIC))
+                .filter(m -> qualifiers().tool().isSameType(m.getReturnType(), componentElement.asType()))
+                .collect(Collectors.toList());
+        if (methods.isEmpty()) {
+            throw new ValidationFailure("Build method not found", element());
+        }
+        if (methods.size() != 1) {
+            throw new ValidationFailure("Only one build method allowed", element());
+        }
+        ExecutableElement result = methods.get(0);
+        if (!result.getParameters().isEmpty()) {
+            throw new ValidationFailure("The build method may not have any parameters", result);
+        }
+        return result;
+    });
+
+    private final Supplier<List<ExecutableElement>> setterMethods = memoize(() -> {
+        ExecutableElement buildMethod = buildMethod();
+        List<ExecutableElement> result = ElementFilter.methodsIn(element().getEnclosedElements()).stream()
+                .filter(m -> !m.getModifiers().contains(STATIC))
+                .filter(m -> !Objects.equals(m, buildMethod))
+                .collect(Collectors.toList());
+        for (ExecutableElement m : result) {
+            if (!qualifiers().tool().isSameType(m.getReturnType(), element().asType())) {
+                throw new ValidationFailure("The setter method must return the builder type", m);
+            }
+            if (m.getParameters().size() != 1) {
+                throw new ValidationFailure("The setter method must have exactly one parameter", m);
+            }
+        }
+        return result;
+    });
+
+    BuilderElement(
+            TypeElement element,
+            ClassName parentClass,
+            KeyFactory keyFactory) {
+        this.element = element;
+        this.parentClass = parentClass;
+        this.keyFactory = keyFactory;
+    }
+
+    public TypeElement element() {
+        return element;
+    }
+
+    public ClassName generatedClass() {
+        return parentClass.nestedClass(element().getSimpleName() + "_Impl");
+    }
+
+    public ExecutableElement buildMethod() {
+        return buildMethod.get();
+    }
+
+    List<ParameterBinding> parameterBindings() {
+        return setterMethods().stream()
+                .map(p -> ParameterBinding.create(p, qualifiers()))
+                .collect(Collectors.toList());
+    }
+
+    List<ExecutableElement> setterMethods() {
+        return setterMethods.get();
+    }
+
+    private KeyFactory qualifiers() {
+        return keyFactory;
+    }
+}

compiler/src/main/java/io/jbock/simple/processor/binding/ComponentElement.java

@@ -10,7 +10,6 @@
 import javax.lang.model.element.ExecutableElement;
 import javax.lang.model.element.Modifier;
 import javax.lang.model.element.TypeElement;
-import javax.lang.model.element.VariableElement;
 import javax.lang.model.type.TypeKind;
 import java.util.Collection;
 import java.util.LinkedHashMap;
@@ -38,17 +37,33 @@ public final class ComponentElement {
         for (Element el : element().getEnclosedElements()) {
             boolean hasFactoryAnnotation = el.getAnnotation(Component.Factory.class) != null;
             if (!hasFactoryAnnotation) {
-                return Optional.empty();
+                continue;
             }
             TypeElement tel = Visitors.TYPE_ELEMENT_VISITOR.visit(el);
             if (tel == null) {
-                return Optional.empty();
+                continue;
             }
             return Optional.of(new FactoryElement(tel, generatedClass(), keyFactory()));
         }
         return Optional.empty();
     });
 
+
+    private final Supplier<Optional<BuilderElement>> builderElement = memoize(() -> {
+        for (Element el : element().getEnclosedElements()) {
+            boolean hasBuilderAnnotation = el.getAnnotation(Component.Builder.class) != null;
+            if (!hasBuilderAnnotation) {
+                continue;
+            }
+            TypeElement tel = Visitors.TYPE_ELEMENT_VISITOR.visit(el);
+            if (tel == null) {
+                continue;
+            }
+            return Optional.of(new BuilderElement(tel, generatedClass(), keyFactory()));
+        }
+        return Optional.empty();
+    });
+
     private final Supplier<Map<Key, InjectBinding>> providesBindings = memoize(() -> {
         List<ExecutableElement> methods = methodsIn(element().getEnclosedElements());
         Map<Key, InjectBinding> result = new LinkedHashMap<>();
@@ -91,14 +106,15 @@ public final class ComponentElement {
     private final Supplier<Map<Key, ParameterBinding>> parameterBindings = memoize(() -> {
         List<ParameterBinding> pBindings = factoryElement()
                 .map(FactoryElement::parameterBindings)
+                .or(() -> builderElement().map(BuilderElement::parameterBindings))
                 .orElse(List.of());
         Map<Key, ParameterBinding> result = new LinkedHashMap<>();
         for (ParameterBinding b : pBindings) {
             ParameterBinding previousBinding = result.put(b.key(), b);
             if (previousBinding != null) {
-                VariableElement p = previousBinding.parameter();
+                Element p = previousBinding.element();
                 throw new ValidationFailure("The binding is in conflict with another parameter: " +
-                        p.asType() + ' ' + p.getSimpleName(), b.parameter());
+                        p.asType() + ' ' + p.getSimpleName(), b.element());
             }
         }
         return result;
@@ -125,6 +141,10 @@ public Optional<FactoryElement> factoryElement() {
         return factoryElement.get();
     }
 
+    public Optional<BuilderElement> builderElement() {
+        return builderElement.get();
+    }
+
     public boolean isComponentRequest(Binding binding) {
         return requests.get().containsKey(binding.key());
     }

compiler/src/main/java/io/jbock/simple/processor/binding/KeyFactory.java

@@ -78,6 +78,10 @@ private boolean hasQualifierAnnotation(AnnotationMirror mirror) {
         return tool.hasQualifierAnnotation(element);
     }
 
+    TypeTool tool() {
+        return tool;
+    }
+
     @Override
     public void clearCache() {
         keyCache.clear();

compiler/src/main/java/io/jbock/simple/processor/binding/ParameterBinding.java

@@ -4,28 +4,30 @@
 import io.jbock.javapoet.ParameterSpec;
 
 import javax.lang.model.element.Element;
+import javax.lang.model.element.ExecutableElement;
 import javax.lang.model.element.VariableElement;
 import java.util.List;
 import java.util.function.Function;
 
 public final class ParameterBinding extends Binding {
 
-    private final VariableElement parameter;
+    private final Element element; // VariableElement or ExecutableElement (setter)
 
     private ParameterBinding(
             Key key,
-            VariableElement parameter) {
+            Element element) {
         super(key);
-        this.parameter = parameter;
+        this.element = element;
     }
 
     public static ParameterBinding create(VariableElement parameter, KeyFactory keyFactory) {
         Key key = keyFactory.getKey(parameter);
         return new ParameterBinding(key, parameter);
     }
 
-    public VariableElement parameter() {
-        return parameter;
+    public static ParameterBinding create(ExecutableElement setter, KeyFactory keyFactory) {
+        Key key = keyFactory.getKey(setter.getParameters().get(0));
+        return new ParameterBinding(key, setter);
     }
 
     @Override
@@ -40,7 +42,7 @@ public String toString() {
 
     @Override
     public Element element() {
-        return parameter;
+        return element;
     }
 
     @Override
@@ -50,6 +52,6 @@ public List<DependencyRequest> requests() {
 
     @Override
     public String suggestedVariableName() {
-        return parameter.getSimpleName().toString();
+        return element.getSimpleName().toString();
     }
 }

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

@@ -36,7 +36,9 @@ public ComponentFactoryStep(
 
     @Override
     public Set<String> annotations() {
-        return Set.of(Component.Factory.class.getCanonicalName());
+        return Set.of(
+                Component.Factory.class.getCanonicalName(),
+                Component.Builder.class.getCanonicalName());
     }
 
     @Override
@@ -52,11 +54,12 @@ public Set<? extends Element> process(Map<String, Set<Element>> elementsByAnnota
                 if (enclosing.getAnnotation(Component.class) == null) {
                     throw new ValidationFailure("The @Factory must be nested inside a @Component", typeElement);
                 }
-                if (enclosing.getEnclosedElements().stream()
-                        .filter(enclosed -> enclosed.getKind().isInterface())
-                        .filter(enclosed -> enclosed.getAnnotation(Component.Factory.class) != null)
+                List<? extends Element> siblings = enclosing.getEnclosedElements();
+                if (siblings.stream()
+                        .filter(sibling -> sibling.getAnnotation(Component.Factory.class) != null
+                                || sibling.getAnnotation(Component.Builder.class) != null)
                         .count() >= 2) {
-                    throw new ValidationFailure("Found more than one @Factory", enclosing);
+                    throw new ValidationFailure("Only one @Factory or @Builder allowed", enclosing);
                 }
                 for (ExecutableElement m : ElementFilter.methodsIn(typeElement.getEnclosedElements())) {
                     if (m.getModifiers().contains(Modifier.ABSTRACT)) {

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

@@ -46,6 +46,10 @@ public boolean isSameType(TypeMirror mirror, String canonicalName) {
         return types.isSameType(mirror, typeElement.asType());
     }
 
+    public boolean isSameType(TypeMirror mirror, TypeMirror other) {
+        return types.isSameType(mirror, other);
+    }
+
     public boolean hasInjectAnnotation(Element m) {
         if (m.getKind() != ElementKind.CONSTRUCTOR && m.getKind() != ElementKind.METHOD) {
             return false;

simple-component/src/main/java/io/jbock/simple/Component.java

@@ -12,13 +12,13 @@
  * have the name of the type annotated, appended with {@code _Impl}. For
  * example, {@code @Component interface MyComponent {...}} will produce an implementation named
  * {@code MyComponent_Impl}.
- * 
+ *
  * <h2>Component methods</h2>
  *
  * <p>Every type annotated with {@code @Component} must contain at least one abstract component
  * method. Component methods may have any name, but must have no parameters and return a bound type.
  * A bound type is one of the following:
- * 
+ *
  * <ul>
  *     <li>an {@link Inject injected} type
  *     <li>a {@link Provides provided} type
@@ -34,20 +34,26 @@
      * A factory for a component. Components <em>may</em> have a single nested {@code interface}
      * annotated with {@code @Component.Factory}.
      *
-     * <p>A factory is a type with a single method that returns a new component instance each time it
-     * is called. The parameters of that method allow the caller to provide the bound instances
+     * <p>A factory is an interface with a single method that returns a new component instance each time it
+     * is called. The parameters of that method provide the bound instances
      * required by the component.
-     *
-     * <p>Components may have a single nested {@code interface}
-     * annotated with {@code @Component.Factory}. Factory types must follow some rules:
-     *
-     * <ul>
-     *   <li>There must be exactly one abstract method, which must return the component type.
-     *   <li>The method parameters bind the instance passed for that parameter within the component.
-     * </ul>
      */
     @Target(TYPE)
     @Retention(SOURCE)
     @interface Factory {
     }
+
+    /**
+     * A builder for a component. Components <em>may</em> have a single nested {@code interface}
+     * annotated with {@code @Component.Builder}.
+     *
+     * <p>The builder is an interface with zero or more setter methods that return the builder type.
+     * Additionally, there must be exactly one abstract no-argument method that returns the component
+     * type, called the "build method". The setter methods provide the bound instances
+     * required by the component.
+     */
+    @Retention(SOURCE)
+    @Target(TYPE)
+    @interface Builder {
+    }
 }