refactoring, add UniqueNameSet

Author: h908714124

compiler/src/main/java/net/jbock/annotated/AnnotatedMethodsFactory.java

@@ -2,20 +2,13 @@
 
 import io.jbock.util.Either;
 import jakarta.inject.Inject;
-import net.jbock.common.SnakeName;
 import net.jbock.common.ValidationFailure;
 import net.jbock.processor.SourceElement;
 import net.jbock.validate.ValidateScope;
 
-import javax.lang.model.element.Name;
 import java.util.Comparator;
-import java.util.HashMap;
-import java.util.HashSet;
 import java.util.List;
-import java.util.Locale;
-import java.util.Map;
 import java.util.Optional;
-import java.util.Set;
 
 import static java.util.stream.Collectors.toList;
 import static net.jbock.common.Constants.instancesOf;
@@ -39,10 +32,8 @@ public class AnnotatedMethodsFactory {
 
     public Either<List<ValidationFailure>, AnnotatedMethods> createAnnotatedMethods() {
         return executableElementsFinder.findExecutableElements()
-                .map(EnumNamesBuilder::builder)
-                .map(builder -> builder.withSourceElement(sourceElement))
-                .map(builder -> builder.withEnumNames(createEnumNames(builder.methods())))
-                .flatMap(EnumNames::createAnnotatedMethods)
+                .map(methods -> new SourceElementWithMethods(sourceElement, methods))
+                .flatMap(SourceElementWithMethods::validListOfAnnotatedMethods)
                 .map(AnnotatedMethodsBuilder::builder)
                 .map(builder -> builder.withNamedOptions(builder.annotatedMethods()
                         .flatMap(instancesOf(AnnotatedOption.class))
@@ -67,20 +58,4 @@ private Optional<List<ValidationFailure>> validateAtLeastOneParameterInSuperComm
                 " when the superCommand attribute is set";
         return Optional.of(List.of(sourceElement.fail(message)));
     }
-
-    private Map<Name, String> createEnumNames(List<Executable> methods) {
-        Set<String> enumNames = new HashSet<>(methods.size());
-        Map<Name, String> result = new HashMap<>(methods.size());
-        for (Executable method : methods) {
-            String enumName = "_".contentEquals(method.simpleName()) ?
-                    "_1" : // avoid potential keyword issue
-                    SnakeName.create(method.simpleName()).snake('_').toUpperCase(Locale.US);
-            while (!enumNames.add(enumName)) {
-                String suffix = enumName.endsWith("1") ? "1" : "_1";
-                enumName = enumName + suffix;
-            }
-            result.put(method.simpleName(), enumName);
-        }
-        return result;
-    }
 }

compiler/src/main/java/net/jbock/annotated/EnumNamesBuilder.java

@@ -1,6 +1,7 @@
 package net.jbock.annotated;
 
 import io.jbock.util.Either;
+import net.jbock.common.SnakeName;
 import net.jbock.common.Util;
 import net.jbock.common.ValidationFailure;
 import net.jbock.processor.SourceElement;
@@ -9,7 +10,7 @@
 import javax.lang.model.element.Name;
 import javax.lang.model.type.DeclaredType;
 import java.util.List;
-import java.util.Map;
+import java.util.Locale;
 import java.util.Optional;
 
 import static io.jbock.util.Either.right;
@@ -22,18 +23,19 @@
 import static net.jbock.common.TypeTool.AS_TYPE_ELEMENT;
 import static net.jbock.common.Util.checkNoDuplicateAnnotations;
 
-final class EnumNames {
+final class SourceElementWithMethods {
 
-    private final EnumNamesBuilder.Step2 step2;
-    private final Map<Name, String> enumNames;
+    private final SourceElement sourceElement;
+    private final List<Executable> methods;
+    private final UniqueNameSet uniqueNameSet = new UniqueNameSet();
 
-    EnumNames(EnumNamesBuilder.Step2 step2, Map<Name, String> enumNames) {
-        this.step2 = step2;
-        this.enumNames = enumNames;
+    SourceElementWithMethods(SourceElement sourceElement, List<Executable> methods) {
+        this.methods = methods;
+        this.sourceElement = sourceElement;
     }
 
-    Either<List<ValidationFailure>, List<AnnotatedMethod>> createAnnotatedMethods() {
-        return methods().stream()
+    Either<List<ValidationFailure>, List<AnnotatedMethod>> validListOfAnnotatedMethods() {
+        return methods.stream()
                 .map(this::createAnnotatedMethod)
                 .collect(allFailures());
     }
@@ -44,7 +46,7 @@ private Either<ValidationFailure, AnnotatedMethod> createAnnotatedMethod(
         ExecutableElement method = sourceMethod.method();
         return checkNoDuplicateAnnotations(method, methodLevelAnnotations())
                 .<Either<ValidationFailure, AnnotatedMethod>>map(Either::left)
-                .orElseGet(() -> right(sourceMethod.annotatedMethod(sourceElement(), enumName)))
+                .orElseGet(() -> right(sourceMethod.annotatedMethod(sourceElement, enumName)))
                 .filter(this::checkAccessibleReturnType);
     }
 
@@ -72,15 +74,10 @@ private boolean isInaccessible(DeclaredType declared) {
                 .anyMatch(this::isInaccessible);
     }
 
-    private SourceElement sourceElement() {
-        return step2.sourceElement;
-    }
-
     private String enumNameFor(Name sourceMethodName) {
-        return enumNames.get(sourceMethodName);
-    }
-
-    private List<Executable> methods() {
-        return step2.methods();
+        String enumName = "_".contentEquals(sourceMethodName) ?
+                "_1" : // avoid potential keyword issue
+                SnakeName.create(sourceMethodName).snake('_').toUpperCase(Locale.ROOT);
+        return uniqueNameSet.getUniqueName(enumName);
     }
 }

…/java/net/jbock/annotated/EnumNames.java …/annotated/SourceElementWithMethods.javacompiler/src/main/java/net/jbock/annotated/EnumNames.java renamed to compiler/src/main/java/net/jbock/annotated/SourceElementWithMethods.java compiler/src/main/java/net/jbock/annotated/EnumNames.java renamed to compiler/src/main/java/net/jbock/annotated/SourceElementWithMethods.java

@@ -0,0 +1,37 @@
+/*
+ * Copyright (C) 2016 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package net.jbock.annotated;
+
+import java.util.HashSet;
+import java.util.Set;
+
+/** A collector for names to be used in the same namespace that should not conflict. */
+final class UniqueNameSet {
+  private final Set<String> uniqueNames = new HashSet<>();
+
+  /**
+   * Generates a unique name using {@code base}. If {@code base} has not yet been added, it will be
+   * returned as-is. If your {@code base} is healthy, this will always return {@code base}.
+   */
+  String getUniqueName(CharSequence base) {
+    String name = base.toString();
+    for (int differentiator = 2; !uniqueNames.add(name); differentiator++) {
+      name = base.toString() + differentiator;
+    }
+    return name;
+  }
+}