refactoring / rename parser classes

h908714124 · h908714124 · commit a2d0d115f5b4 · 2022-04-02T08:42:23.000+02:00
diff --git a/compiler/src/main/java/net/jbock/writing/CreateModelMethod.java b/compiler/src/main/java/net/jbock/writing/CreateModelMethod.java
@@ -37,14 +37,13 @@ final class CreateModelMethod extends HasCommandRepresentation {
             code.add(CodeBlock.of(".addDescriptionLine($S)", descriptionLine));
         }
         code.add(CodeBlock.of(".withProgramName($S)", sourceElement().programName()));
-        if (sourceElement().isSuperCommand()) {
+        if (isSuperCommand()) {
             code.add(CodeBlock.of(".withSuperCommand($L)", true));
         }
         for (Mapping<AnnotatedOption> c : namedOptions()) {
             code.add(CodeBlock.of(".addOption($L)", optionBlock(c)));
         }
-        Stream.of(positionalParameters(), varargsParameters())
-                .flatMap(List::stream)
+        Stream.concat(positionalParameters().stream(), varargsParameter().stream())
                 .forEach(c -> code.add(CodeBlock.of(".addParameter($L)", parameterBlock(c))));
         code.add(CodeBlock.of(".build()"));
         return methodBuilder("createModel")
diff --git a/compiler/src/main/java/net/jbock/writing/GeneratedAnnotation.java b/compiler/src/main/java/net/jbock/writing/GeneratedAnnotation.java
@@ -7,7 +7,7 @@
 
 import javax.annotation.processing.Generated;
 
-class GeneratedAnnotation {
+final class GeneratedAnnotation {
 
     @Inject
     GeneratedAnnotation() {
diff --git a/compiler/src/main/java/net/jbock/writing/GeneratedTypes.java b/compiler/src/main/java/net/jbock/writing/GeneratedTypes.java
@@ -12,7 +12,7 @@
 import static net.jbock.common.Constants.EITHER;
 
 @WritingScope
-class GeneratedTypes extends HasCommandRepresentation {
+final class GeneratedTypes extends HasCommandRepresentation {
 
     @Inject
     GeneratedTypes(CommandRepresentation commandRepresentation) {
@@ -24,7 +24,7 @@ TypeName parseSuccessType() {
     }
 
     Optional<TypeName> superResultType() {
-        if (!sourceElement().isSuperCommand()) {
+        if (!isSuperCommand()) {
             return Optional.empty();
         }
         ParameterizedTypeName type = ParameterizedTypeName.get(
diff --git a/compiler/src/main/java/net/jbock/writing/HasCommandRepresentation.java b/compiler/src/main/java/net/jbock/writing/HasCommandRepresentation.java
@@ -9,6 +9,7 @@
 import net.jbock.processor.SourceElement;
 
 import java.util.List;
+import java.util.Optional;
 
 abstract class HasCommandRepresentation {
 
@@ -38,11 +39,15 @@ final List<Mapping<AnnotatedParameter>> positionalParameters() {
         return commandRepresentation.positionalParameters();
     }
 
-    final List<Mapping<AnnotatedVarargsParameter>> varargsParameters() {
-        return commandRepresentation.varargsParameters();
+    final Optional<Mapping<AnnotatedVarargsParameter>> varargsParameter() {
+        return commandRepresentation.varargsParameters().stream().findAny();
     }
 
-    List<Mapping<?>> allMappings() {
+    final List<Mapping<?>> allMappings() {
         return commandRepresentation.allMappings();
     }
+
+    final boolean isSuperCommand() {
+        return commandRepresentation.sourceElement().isSuperCommand();
+    }
 }
diff --git a/compiler/src/main/java/net/jbock/writing/ImplClass.java b/compiler/src/main/java/net/jbock/writing/ImplClass.java
@@ -33,12 +33,10 @@
 import static net.jbock.writing.CodeBlocks.joinByNewline;
 
 /**
- * Defines the *_Impl class, which extends the command class.
- *
- * @see ParserClass
+ * Implementation of the command class.
  */
 @WritingScope
-public class ImplClass extends HasCommandRepresentation {
+final class ImplClass extends HasCommandRepresentation {
 
     private final GeneratedTypes generatedTypes;
 
@@ -49,7 +47,7 @@ public class ImplClass extends HasCommandRepresentation {
         this.generatedTypes = generatedTypes;
     }
 
-    public TypeSpec define() {
+    TypeSpec define() {
         TypeSpec.Builder spec = TypeSpec.classBuilder(generatedTypes.implType());
         if (sourceElement().isInterface()) {
             spec.addSuperinterface(sourceElement().typeName());
@@ -97,9 +95,8 @@ private MethodSpec constructor() {
             Mapping<AnnotatedParameter> m = positionalParameters().get(i);
             spec.addStatement("this.$N = $L", m.field(), convertExpressionParameter(m, i));
         }
-        varargsParameters().forEach(m -> {
-            spec.addStatement("this.$N = $L", m.field(), convertExpressionVarargsParameter(m));
-        });
+        varargsParameter().ifPresent(m ->
+                spec.addStatement("this.$N = $L", m.field(), convertExpressionVarargsParameter(m)));
         return spec.addParameter(result())
                 .addException(ExFailure.class)
                 .build();
diff --git a/compiler/src/main/java/net/jbock/writing/OptEnum.java b/compiler/src/main/java/net/jbock/writing/OptEnum.java
@@ -13,7 +13,7 @@
  * @see ParserClass
  */
 @WritingScope
-class OptEnum extends HasCommandRepresentation {
+final class OptEnum extends HasCommandRepresentation {
 
     @Inject
     OptEnum(CommandRepresentation commandRepresentation) {
diff --git a/compiler/src/main/java/net/jbock/writing/ParseOrExitMethod.java b/compiler/src/main/java/net/jbock/writing/ParseOrExitMethod.java
@@ -13,7 +13,7 @@
 import static net.jbock.common.Constants.STRING_ARRAY;
 
 @WritingScope
-class ParseOrExitMethod extends HasCommandRepresentation {
+final class ParseOrExitMethod extends HasCommandRepresentation {
 
     private final GeneratedTypes generatedTypes;
     private final ParseMethod parseMethod;
diff --git a/compiler/src/main/java/net/jbock/writing/ParserClass.java b/compiler/src/main/java/net/jbock/writing/ParserClass.java
@@ -9,7 +9,7 @@
  * Generates the *Parser class.
  */
 @WritingScope
-public final class ParserClass extends HasCommandRepresentation {
+final class ParserClass extends HasCommandRepresentation {
 
     private final ParseMethod parseMethod;
     private final OptEnum optionEnum;
diff --git a/compiler/src/main/java/net/jbock/writing/ParserTypeFactory.java b/compiler/src/main/java/net/jbock/writing/ParserTypeFactory.java
@@ -4,8 +4,8 @@
 import io.jbock.javapoet.CodeBlock;
 import io.jbock.javapoet.ParameterizedTypeName;
 import jakarta.inject.Inject;
-import net.jbock.parse.RestParser;
-import net.jbock.parse.RestlessParser;
+import net.jbock.parse.VarargsParameterParser;
+import net.jbock.parse.StandardParser;
 import net.jbock.parse.SuperParser;
 
 import java.util.Map;
@@ -34,23 +34,23 @@ final class ParserTypeFactory extends HasCommandRepresentation {
                 CodeBlock.of("$T.of()", Map.class) :
                 CodeBlock.of("$N()", optionStatesMethod().get());
         int numParams = positionalParameters().size();
-        if (sourceElement().isSuperCommand()) {
+        if (isSuperCommand()) {
             ClassName parserClass = ClassName.get(SuperParser.class);
             CodeBlock init = CodeBlock.of("$T.create($L, $L, $L)",
                     ClassName.get(SuperParser.class),
                     optionNames, optionStates, numParams);
             return new ParserType(ParameterizedTypeName.get(parserClass, optType()), init);
         }
-        if (!varargsParameters().isEmpty()) {
-            ClassName parserClass = ClassName.get(RestParser.class);
+        if (varargsParameter().isPresent()) {
+            ClassName parserClass = ClassName.get(VarargsParameterParser.class);
             CodeBlock init = CodeBlock.of("$T.create($L, $L, $L)",
-                    ClassName.get(RestParser.class),
+                    ClassName.get(VarargsParameterParser.class),
                     optionNames, optionStates, numParams);
             return new ParserType(ParameterizedTypeName.get(parserClass, optType()), init);
         }
-        ClassName parserClass = ClassName.get(RestlessParser.class);
+        ClassName parserClass = ClassName.get(StandardParser.class);
         CodeBlock init = CodeBlock.of("$T.create($L, $L, $L)",
-                ClassName.get(RestlessParser.class),
+                ClassName.get(StandardParser.class),
                 optionNames, optionStates, numParams);
         return new ParserType(ParameterizedTypeName.get(parserClass, optType()), init);
     });
diff --git a/jbock/src/main/java/net/jbock/parse/StandardParser.java b/jbock/src/main/java/net/jbock/parse/StandardParser.java
@@ -16,9 +16,9 @@
  *
  * @param <T> type of keys that identify named options
  */
-public final class RestlessParser<T> extends SubParser<T> {
+public final class StandardParser<T> extends SubParser<T> {
 
-    private RestlessParser(
+    private StandardParser(
             Map<String, T> optionNames,
             Map<T, OptionState> optionStates,
             int numParams) {
@@ -35,11 +35,11 @@ private RestlessParser(
      *
      * @return a parser instance
      */
-    public static <T> RestlessParser<T> create(
+    public static <T> StandardParser<T> create(
             Map<String, T> optionNames,
             Map<T, OptionState> optionStates,
             int numParams) {
-        return new RestlessParser<>(optionNames, optionStates, numParams);
+        return new StandardParser<>(optionNames, optionStates, numParams);
     }
 
     @Override
diff --git a/jbock/src/main/java/net/jbock/parse/VarargsParameterParser.java b/jbock/src/main/java/net/jbock/parse/VarargsParameterParser.java
@@ -13,11 +13,11 @@
  *
  * @param <T> type of keys that identify named options
  */
-public final class RestParser<T> extends SubParser<T> {
+public final class VarargsParameterParser<T> extends SubParser<T> {
 
     private final List<String> rest = new ArrayList<>();
 
-    private RestParser(
+    private VarargsParameterParser(
             Map<String, T> optionNames,
             Map<T, OptionState> optionStates,
             int numParams) {
@@ -34,11 +34,11 @@ private RestParser(
      *
      * @return a parser instance
      */
-    public static <T> RestParser<T> create(
+    public static <T> VarargsParameterParser<T> create(
             Map<String, T> optionNames,
             Map<T, OptionState> optionStates,
             int numParams) {
-        return new RestParser<>(optionNames, optionStates, numParams);
+        return new VarargsParameterParser<>(optionNames, optionStates, numParams);
     }
 
     @Override
diff --git a/jbock/src/test/java/net/jbock/parse/StandardParserTest.java b/jbock/src/test/java/net/jbock/parse/StandardParserTest.java
@@ -14,45 +14,45 @@
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.when;
 
-class RestlessParserTest {
+class StandardParserTest {
 
     @Test
     void testZeroParamsExcess() {
-        RestlessParser<String> parser = RestlessParser.create(Map.of(), Map.of(), 0);
+        StandardParser<String> parser = StandardParser.create(Map.of(), Map.of(), 0);
         assertThrows(ExToken.class, () -> parser.parse(List.of("1")));
     }
 
     @Test
     void testZeroParamsSuspicious() {
-        RestlessParser<String> parser = RestlessParser.create(Map.of(), Map.of(), 0);
+        StandardParser<String> parser = StandardParser.create(Map.of(), Map.of(), 0);
         assertThrows(ExToken.class, () -> parser.parse(List.of("-a")));
     }
 
     @Test
     void testZeroParamsSuccessEmpty() throws ExToken {
-        RestlessParser<String> parser = RestlessParser.create(Map.of(), Map.of(), 0);
+        StandardParser<String> parser = StandardParser.create(Map.of(), Map.of(), 0);
         parser.parse(List.of());
         assertTrue(parser.option("a").findAny().isEmpty());
         assertTrue(parser.param(0).isEmpty());
     }
 
     @Test
     void testZeroParamsSuccessEscape() throws ExToken {
-        RestlessParser<String> parser = RestlessParser.create(Map.of(), Map.of(), 0);
+        StandardParser<String> parser = StandardParser.create(Map.of(), Map.of(), 0);
         parser.parse(List.of("--"));
         assertTrue(parser.option("a").findAny().isEmpty());
         assertTrue(parser.param(0).isEmpty());
     }
 
     @Test
     void testOneParamExcess() {
-        RestlessParser<String> parser = RestlessParser.create(Map.of(), Map.of(), 1);
+        StandardParser<String> parser = StandardParser.create(Map.of(), Map.of(), 1);
         assertThrows(ExToken.class, () -> parser.parse(List.of("1", "2")));
     }
 
     @Test
     void testOneParamSuccess() throws ExToken {
-        RestlessParser<String> parser = RestlessParser.create(Map.of(), Map.of(), 1);
+        StandardParser<String> parser = StandardParser.create(Map.of(), Map.of(), 1);
         parser.parse(List.of("1"));
         assertTrue(parser.option("a").findAny().isEmpty());
         assertEquals(Optional.of("1"), parser.param(0));
@@ -62,7 +62,7 @@ void testOneParamSuccess() throws ExToken {
     void testOneUnixOptionAttached() throws ExToken {
         Map<String, String> optionNames = Map.of("-a", "A");
         Map<String, OptionState> optionStates = Map.of("A", new OptionStateNonRepeatable());
-        RestlessParser<String> parser = RestlessParser.create(optionNames, optionStates, 0);
+        StandardParser<String> parser = StandardParser.create(optionNames, optionStates, 0);
         parser.parse(List.of("-a1"));
         assertEquals(List.of("1"), parser.option("A").toList());
     }
@@ -71,7 +71,7 @@ void testOneUnixOptionAttached() throws ExToken {
     void testOneUnixOptionDetached() throws ExToken {
         Map<String, String> optionNames = Map.of("-a", "A");
         Map<String, OptionState> optionStates = Map.of("A", new OptionStateNonRepeatable());
-        RestlessParser<String> parser = RestlessParser.create(optionNames, optionStates, 0);
+        StandardParser<String> parser = StandardParser.create(optionNames, optionStates, 0);
         parser.parse(List.of("-a", "1"));
         assertEquals(List.of("1"), parser.option("A").toList());
     }
@@ -80,7 +80,7 @@ void testOneUnixOptionDetached() throws ExToken {
     void testOneUnixOptionClusterFail() {
         Map<String, String> optionNames = Map.of("-a", "A");
         Map<String, OptionState> optionStates = Map.of("A", new OptionStateModeFlag());
-        RestlessParser<String> parser = RestlessParser.create(optionNames, optionStates, 0);
+        StandardParser<String> parser = StandardParser.create(optionNames, optionStates, 0);
         assertThrows(ExToken.class, () -> parser.parse(List.of("-ab")));
     }
 
@@ -91,15 +91,15 @@ void testOneUnixOptionClusterBadOptionState() throws ExToken {
         when(optionState.read(any(), any()))
                 .thenReturn("readOptionName_invalid_input");
         Map<String, OptionState> optionStates = Map.of("A", optionState);
-        RestlessParser<String> parser = RestlessParser.create(optionNames, optionStates, 0);
+        StandardParser<String> parser = StandardParser.create(optionNames, optionStates, 0);
         assertThrows(ExToken.class, () -> parser.parse(List.of("-a-")));
     }
 
     @Test
     void testOneGnuOptionAttached() throws ExToken {
         Map<String, String> optionNames = Map.of("--alpha", "A");
         Map<String, OptionState> optionStates = Map.of("A", new OptionStateNonRepeatable());
-        RestlessParser<String> parser = RestlessParser.create(optionNames, optionStates, 0);
+        StandardParser<String> parser = StandardParser.create(optionNames, optionStates, 0);
         parser.parse(List.of("--alpha=1"));
         assertEquals(List.of("1"), parser.option("A").toList());
     }
@@ -108,7 +108,7 @@ void testOneGnuOptionAttached() throws ExToken {
     void testOneGnuOptionDetached() throws ExToken {
         Map<String, String> optionNames = Map.of("--alpha", "A");
         Map<String, OptionState> optionStates = Map.of("A", new OptionStateNonRepeatable());
-        RestlessParser<String> parser = RestlessParser.create(optionNames, optionStates, 0);
+        StandardParser<String> parser = StandardParser.create(optionNames, optionStates, 0);
         parser.parse(List.of("--alpha", "1"));
         assertEquals(List.of("1"), parser.option("A").toList());
     }
@@ -119,7 +119,7 @@ void testTwoUnixOptionsAttached() throws ExToken {
         Map<String, OptionState> optionStates = Map.of(
                 "A", new OptionStateModeFlag(),
                 "B", new OptionStateNonRepeatable());
-        RestlessParser<String> parser = RestlessParser.create(optionNames, optionStates, 0);
+        StandardParser<String> parser = StandardParser.create(optionNames, optionStates, 0);
         parser.parse(List.of("-a", "-b1"));
         assertTrue(parser.option("A").findAny().isPresent());
         assertEquals(List.of("1"), parser.option("B").toList());
@@ -131,7 +131,7 @@ void testTwoUnixOptionsDetached() throws ExToken {
         Map<String, OptionState> optionStates = Map.of(
                 "A", new OptionStateModeFlag(),
                 "B", new OptionStateNonRepeatable());
-        RestlessParser<String> parser = RestlessParser.create(optionNames, optionStates, 0);
+        StandardParser<String> parser = StandardParser.create(optionNames, optionStates, 0);
         parser.parse(List.of("-a", "-b", "1"));
         assertTrue(parser.option("A").findAny().isPresent());
         assertEquals(List.of("1"), parser.option("B").toList());
@@ -143,7 +143,7 @@ void testTwoUnixOptionsClusteringAttached() throws ExToken {
         Map<String, OptionState> optionStates = Map.of(
                 "A", new OptionStateModeFlag(),
                 "B", new OptionStateNonRepeatable());
-        RestlessParser<String> parser = RestlessParser.create(optionNames, optionStates, 0);
+        StandardParser<String> parser = StandardParser.create(optionNames, optionStates, 0);
         parser.parse(List.of("-ab1"));
         assertTrue(parser.option("A").findAny().isPresent());
         assertEquals(List.of("1"), parser.option("B").toList());
@@ -155,7 +155,7 @@ void testTwoUnixOptionsClusteringDetached() throws ExToken {
         Map<String, OptionState> optionStates = Map.of(
                 "A", new OptionStateModeFlag(),
                 "B", new OptionStateNonRepeatable());
-        RestlessParser<String> parser = RestlessParser.create(optionNames, optionStates, 0);
+        StandardParser<String> parser = StandardParser.create(optionNames, optionStates, 0);
         parser.parse(List.of("-ab", "1"));
         assertTrue(parser.option("A").findAny().isPresent());
         assertEquals(List.of("1"), parser.option("B").toList());
diff --git a/jbock/src/test/java/net/jbock/parse/VarargsParameterParserTest.java b/jbock/src/test/java/net/jbock/parse/VarargsParameterParserTest.java

Original file line number	Diff line number	Diff line change
`@@ -37,14 +37,13 @@ final class CreateModelMethod extends HasCommandRepresentation {`
`37`	`37`	`code.add(CodeBlock.of(".addDescriptionLine($S)", descriptionLine));`
`38`	`38`	`}`
`39`	`39`	`code.add(CodeBlock.of(".withProgramName($S)", sourceElement().programName()));`
`40`		`- if (sourceElement().isSuperCommand()) {`
	`40`	`+ if (isSuperCommand()) {`
`41`	`41`	`code.add(CodeBlock.of(".withSuperCommand($L)", true));`
`42`	`42`	`}`
`43`	`43`	`for (Mapping<AnnotatedOption> c : namedOptions()) {`
`44`	`44`	`code.add(CodeBlock.of(".addOption($L)", optionBlock(c)));`
`45`	`45`	`}`
`46`		`- Stream.of(positionalParameters(), varargsParameters())`
`47`		`- .flatMap(List::stream)`
	`46`	`+ Stream.concat(positionalParameters().stream(), varargsParameter().stream())`
`48`	`47`	`.forEach(c -> code.add(CodeBlock.of(".addParameter($L)", parameterBlock(c))));`
`49`	`48`	`code.add(CodeBlock.of(".build()"));`
`50`	`49`	`return methodBuilder("createModel")`
Original file line number	Diff line number	Diff line change
`@@ -12,7 +12,7 @@`
`12`	`12`	`import static net.jbock.common.Constants.EITHER;`
`13`	`13`
`14`	`14`	`@WritingScope`
`15`		`-class GeneratedTypes extends HasCommandRepresentation {`
	`15`	`+final class GeneratedTypes extends HasCommandRepresentation {`
`16`	`16`
`17`	`17`	`@Inject`
`18`	`18`	`GeneratedTypes(CommandRepresentation commandRepresentation) {`
`@@ -24,7 +24,7 @@ TypeName parseSuccessType() {`
`24`	`24`	`}`
`25`	`25`
`26`	`26`	`Optional<TypeName> superResultType() {`
`27`		`- if (!sourceElement().isSuperCommand()) {`
	`27`	`+ if (!isSuperCommand()) {`
`28`	`28`	`return Optional.empty();`
`29`	`29`	`}`
`30`	`30`	`ParameterizedTypeName type = ParameterizedTypeName.get(`
Original file line number	Diff line number	Diff line change
`@@ -9,6 +9,7 @@`
`9`	`9`	`import net.jbock.processor.SourceElement;`
`10`	`10`
`11`	`11`	`import java.util.List;`
	`12`	`+import java.util.Optional;`
`12`	`13`
`13`	`14`	`abstract class HasCommandRepresentation {`
`14`	`15`
`@@ -38,11 +39,15 @@ final List<Mapping<AnnotatedParameter>> positionalParameters() {`
`38`	`39`	`return commandRepresentation.positionalParameters();`
`39`	`40`	`}`
`40`	`41`
`41`		`- final List<Mapping<AnnotatedVarargsParameter>> varargsParameters() {`
`42`		`- return commandRepresentation.varargsParameters();`
	`42`	`+ final Optional<Mapping<AnnotatedVarargsParameter>> varargsParameter() {`
	`43`	`+ return commandRepresentation.varargsParameters().stream().findAny();`
`43`	`44`	`}`
`44`	`45`
`45`		`- List<Mapping<?>> allMappings() {`
	`46`	`+ final List<Mapping<?>> allMappings() {`
`46`	`47`	`return commandRepresentation.allMappings();`
`47`	`48`	`}`
	`49`	`+`
	`50`	`+ final boolean isSuperCommand() {`
	`51`	`+ return commandRepresentation.sourceElement().isSuperCommand();`
	`52`	`+ }`
`48`	`53`	`}`