refactor/rename

h908714124 · h908714124 · commit bf07e4bdfa15 · 2022-03-22T14:42:11.000+01:00
diff --git a/compiler/src/main/java/net/jbock/annotated/AnnotatedMethods.java b/compiler/src/main/java/net/jbock/annotated/AnnotatedMethods.java
@@ -5,13 +5,13 @@
 public final class AnnotatedMethods {
 
     private final AnnotatedMethodsBuilder.Step3 step3;
-    private final List<AnnotatedVarargsParameter> repeatablePositionalParameters;
+    private final List<AnnotatedVarargsParameter> varargsParameters;
 
     AnnotatedMethods(
             AnnotatedMethodsBuilder.Step3 step3,
-            List<AnnotatedVarargsParameter> repeatablePositionalParameters) {
+            List<AnnotatedVarargsParameter> varargsParameters) {
         this.step3 = step3;
-        this.repeatablePositionalParameters = repeatablePositionalParameters;
+        this.varargsParameters = varargsParameters;
     }
 
     public List<AnnotatedOption> namedOptions() {
@@ -22,7 +22,7 @@ public List<AnnotatedParameter> positionalParameters() {
         return step3.positionalParameters;
     }
 
-    public List<AnnotatedVarargsParameter> repeatablePositionalParameters() {
-        return repeatablePositionalParameters;
+    public List<AnnotatedVarargsParameter> varargsParameters() {
+        return varargsParameters;
     }
 }
diff --git a/compiler/src/main/java/net/jbock/annotated/AnnotatedMethodsBuilder.java b/compiler/src/main/java/net/jbock/annotated/AnnotatedMethodsBuilder.java
@@ -62,8 +62,8 @@ Stream<AnnotatedMethod> annotatedMethods() {
             return step2.step1.annotatedMethods.stream();
         }
 
-        AnnotatedMethods withRepeatablePositionalParameters(List<AnnotatedVarargsParameter> repeatablePositionalParameters) {
-            return new AnnotatedMethods(this, repeatablePositionalParameters);
+        AnnotatedMethods withVarargsParameters(List<AnnotatedVarargsParameter> varargsParameters) {
+            return new AnnotatedMethods(this, varargsParameters);
         }
     }
 }
diff --git a/compiler/src/main/java/net/jbock/annotated/AnnotatedMethodsFactory.java b/compiler/src/main/java/net/jbock/annotated/AnnotatedMethodsFactory.java
@@ -51,7 +51,7 @@ public Either<List<ValidationFailure>, AnnotatedMethods> createAnnotatedMethods(
                         .flatMap(instancesOf(AnnotatedParameter.class))
                         .sorted(indexComparator)
                         .collect(toList())))
-                .map(builder -> builder.withRepeatablePositionalParameters(builder.annotatedMethods()
+                .map(builder -> builder.withVarargsParameters(builder.annotatedMethods()
                         .flatMap(instancesOf(AnnotatedVarargsParameter.class))
                         .collect(toList())))
                 .filter(this::validateAtLeastOneParameterInSuperCommand);
diff --git a/compiler/src/main/java/net/jbock/validate/CommandProcessor.java b/compiler/src/main/java/net/jbock/validate/CommandProcessor.java
@@ -64,7 +64,7 @@ private Optional<List<ValidationFailure>> checkDuplicateDescriptionKeys(
         sourceElement.descriptionKey().ifPresent(keys::add);
         Stream.of(methods.namedOptions(),
                         methods.positionalParameters(),
-                        methods.repeatablePositionalParameters())
+                        methods.varargsParameters())
                 .flatMap(List::stream)
                 .forEach(m -> m.descriptionKey().ifPresent(key -> {
                     if (!keys.add(key)) {
diff --git a/compiler/src/main/java/net/jbock/validate/ContextBuilder.java b/compiler/src/main/java/net/jbock/validate/ContextBuilder.java
@@ -66,22 +66,22 @@ private Step2(Step1 step1, List<Mapping<AnnotatedParameter>> positionalParameter
             this.positionalParameters = positionalParameters;
         }
 
-        List<AnnotatedVarargsParameter> repeatablePositionalParameters() {
-            return step1.step0.abstractMethods.repeatablePositionalParameters();
+        List<AnnotatedVarargsParameter> varargsParameters() {
+            return step1.step0.abstractMethods.varargsParameters();
         }
 
-        Step3 accept(List<Mapping<AnnotatedVarargsParameter>> repeatablePositionalParameters) {
-            return new Step3(this, repeatablePositionalParameters);
+        Step3 accept(List<Mapping<AnnotatedVarargsParameter>> varargsParameters) {
+            return new Step3(this, varargsParameters);
         }
     }
 
     static final class Step3 {
         private final Step2 step2;
-        private final List<Mapping<AnnotatedVarargsParameter>> repeatablePositionalParameters;
+        private final List<Mapping<AnnotatedVarargsParameter>> varargsParameters;
 
-        private Step3(Step2 step2, List<Mapping<AnnotatedVarargsParameter>> repeatablePositionalParameters) {
+        private Step3(Step2 step2, List<Mapping<AnnotatedVarargsParameter>> varargsParameters) {
             this.step2 = step2;
-            this.repeatablePositionalParameters = repeatablePositionalParameters;
+            this.varargsParameters = varargsParameters;
         }
 
         List<AnnotatedOption> namedOptions() {
@@ -101,8 +101,8 @@ public List<Mapping<AnnotatedParameter>> positionalParameters() {
         return step3.step2.positionalParameters;
     }
 
-    public List<Mapping<AnnotatedVarargsParameter>> repeatablePositionalParameters() {
-        return step3.repeatablePositionalParameters;
+    public List<Mapping<AnnotatedVarargsParameter>> varargsParameters() {
+        return step3.varargsParameters;
     }
 
     public CommandRepresentation build() {
diff --git a/compiler/src/main/java/net/jbock/validate/VarargsParameterValidator.java b/compiler/src/main/java/net/jbock/validate/VarargsParameterValidator.java
@@ -31,7 +31,7 @@ class VarargsParameterValidator {
 
     Either<List<ValidationFailure>, ContextBuilder.Step3> wrapRepeatablePositionalParams(
             ContextBuilder.Step2 step) {
-        return validateDuplicateParametersAnnotation(step.repeatablePositionalParameters())
+        return validateDuplicateParametersAnnotation(step.varargsParameters())
                 .filter(this::validateNoRepeatableParameterInSuperCommand)
                 .flatMap(parameters -> parameters.stream()
                         .map(mappingFinder::findMapping)
diff --git a/compiler/src/main/java/net/jbock/writing/CommandRepresentation.java b/compiler/src/main/java/net/jbock/writing/CommandRepresentation.java
@@ -36,8 +36,8 @@ SourceElement sourceElement() {
         return sourceElement;
     }
 
-    List<Mapping<AnnotatedVarargsParameter>> repeatablePositionalParameters() {
-        return contextBuilder.repeatablePositionalParameters();
+    List<Mapping<AnnotatedVarargsParameter>> varargsParameters() {
+        return contextBuilder.varargsParameters();
     }
 
     List<Mapping<AnnotatedParameter>> positionalParameters() {
@@ -66,7 +66,7 @@ ClassName optType() {
     }
 
     private final Supplier<List<Mapping<?>>> allMappings = memoize(() ->
-            Stream.of(namedOptions(), positionalParameters(), repeatablePositionalParameters())
+            Stream.of(namedOptions(), positionalParameters(), varargsParameters())
                     .flatMap(List::stream)
                     .collect(toList()));
 
diff --git a/compiler/src/main/java/net/jbock/writing/CreateModelMethod.java b/compiler/src/main/java/net/jbock/writing/CreateModelMethod.java
@@ -43,7 +43,7 @@ final class CreateModelMethod extends HasCommandRepresentation {
         for (Mapping<AnnotatedOption> c : namedOptions()) {
             code.add(CodeBlock.of(".addOption($L)", optionBlock(c)));
         }
-        Stream.of(positionalParameters(), repeatablePositionalParameters())
+        Stream.of(positionalParameters(), varargsParameters())
                 .flatMap(List::stream)
                 .forEach(c -> code.add(CodeBlock.of(".addParameter($L)", parameterBlock(c))));
         code.add(CodeBlock.of(".build()"));
diff --git a/compiler/src/main/java/net/jbock/writing/ExtractMethod.java b/compiler/src/main/java/net/jbock/writing/ExtractMethod.java
@@ -66,7 +66,7 @@ private GeneratedTypes generatedTypes() {
             ParameterSpec p = asParam(m);
             spec.addStatement("$T $N = $L", p.type, p, convertExpressionRegularParameter(m, i));
         }
-        repeatablePositionalParameters().forEach(m -> {
+        varargsParameters().forEach(m -> {
             ParameterSpec p = asParam(m);
             spec.addStatement("$T $N = $L", p.type, p, convertExpressionRepeatableParameter(m));
         });
@@ -100,7 +100,7 @@ private CodeBlock getConstructorArguments() {
         for (Mapping<AnnotatedParameter> m : positionalParameters()) {
             code.add(CodeBlock.of("$N", asParam(m)));
         }
-        repeatablePositionalParameters().stream()
+        varargsParameters().stream()
                 .map(m -> CodeBlock.of("$N", asParam(m)))
                 .forEach(code::add);
         return joinByComma(code);
diff --git a/compiler/src/main/java/net/jbock/writing/HasCommandRepresentation.java b/compiler/src/main/java/net/jbock/writing/HasCommandRepresentation.java
@@ -38,11 +38,7 @@ final List<Mapping<AnnotatedParameter>> positionalParameters() {
         return commandRepresentation.positionalParameters();
     }
 
-    final List<Mapping<AnnotatedVarargsParameter>> repeatablePositionalParameters() {
-        return commandRepresentation.repeatablePositionalParameters();
-    }
-
-    final CommandRepresentation commandRepresentation() {
-        return commandRepresentation;
+    final List<Mapping<AnnotatedVarargsParameter>> varargsParameters() {
+        return commandRepresentation.varargsParameters();
     }
 }
diff --git a/compiler/src/main/java/net/jbock/writing/ParserTypeFactory.java b/compiler/src/main/java/net/jbock/writing/ParserTypeFactory.java
@@ -41,7 +41,7 @@ final class ParserTypeFactory extends HasCommandRepresentation {
                     optionNames, optionStates, numParams);
             return new ParserType(ParameterizedTypeName.get(parserClass, optType()), init);
         }
-        if (!repeatablePositionalParameters().isEmpty()) {
+        if (!varargsParameters().isEmpty()) {
             ClassName parserClass = ClassName.get(RestParser.class);
             CodeBlock init = CodeBlock.of("$T.create($L, $L, $L)",
                     ClassName.get(RestParser.class),
diff --git a/jbock/src/main/java/net/jbock/contrib/Synopsis.java b/jbock/src/main/java/net/jbock/contrib/Synopsis.java
@@ -63,7 +63,7 @@ List<String> createSynopsis(String prefix) {
                     throw new IllegalArgumentException("unexpected skew: " + skew);
             }
         }
-        repeatableParameter().ifPresent(param -> result.add(param.paramLabel() + "..."));
+        varargsParameter().ifPresent(param -> result.add(param.paramLabel() + "..."));
         return result;
     }
 
@@ -79,7 +79,7 @@ private List<Parameter> regularParameters() {
         return filterBySkew(parameters, sk -> sk != REPEATABLE).collect(toList());
     }
 
-    private Optional<Parameter> repeatableParameter() {
+    private Optional<Parameter> varargsParameter() {
         return filterBySkew(parameters, REPEATABLE).findAny();
     }
 

Original file line number	Diff line number	Diff line change
`@@ -5,13 +5,13 @@`
`5`	`5`	`public final class AnnotatedMethods {`
`6`	`6`
`7`	`7`	`private final AnnotatedMethodsBuilder.Step3 step3;`
`8`		`- private final List<AnnotatedVarargsParameter> repeatablePositionalParameters;`
	`8`	`+ private final List<AnnotatedVarargsParameter> varargsParameters;`
`9`	`9`
`10`	`10`	`AnnotatedMethods(`
`11`	`11`	`AnnotatedMethodsBuilder.Step3 step3,`
`12`		`- List<AnnotatedVarargsParameter> repeatablePositionalParameters) {`
	`12`	`+ List<AnnotatedVarargsParameter> varargsParameters) {`
`13`	`13`	`this.step3 = step3;`
`14`		`- this.repeatablePositionalParameters = repeatablePositionalParameters;`
	`14`	`+ this.varargsParameters = varargsParameters;`
`15`	`15`	`}`
`16`	`16`
`17`	`17`	`public List<AnnotatedOption> namedOptions() {`
`@@ -22,7 +22,7 @@ public List<AnnotatedParameter> positionalParameters() {`
`22`	`22`	`return step3.positionalParameters;`
`23`	`23`	`}`
`24`	`24`
`25`		`- public List<AnnotatedVarargsParameter> repeatablePositionalParameters() {`
`26`		`- return repeatablePositionalParameters;`
	`25`	`+ public List<AnnotatedVarargsParameter> varargsParameters() {`
	`26`	`+ return varargsParameters;`
`27`	`27`	`}`
`28`	`28`	`}`
Original file line number	Diff line number	Diff line change
`@@ -62,8 +62,8 @@ Stream<AnnotatedMethod> annotatedMethods() {`
`62`	`62`	`return step2.step1.annotatedMethods.stream();`
`63`	`63`	`}`
`64`	`64`
`65`		`- AnnotatedMethods withRepeatablePositionalParameters(List<AnnotatedVarargsParameter> repeatablePositionalParameters) {`
`66`		`- return new AnnotatedMethods(this, repeatablePositionalParameters);`
	`65`	`+ AnnotatedMethods withVarargsParameters(List<AnnotatedVarargsParameter> varargsParameters) {`
	`66`	`+ return new AnnotatedMethods(this, varargsParameters);`
`67`	`67`	`}`
`68`	`68`	`}`
`69`	`69`	`}`
Original file line number	Diff line number	Diff line change
`@@ -66,22 +66,22 @@ private Step2(Step1 step1, List<Mapping<AnnotatedParameter>> positionalParameter`
`66`	`66`	`this.positionalParameters = positionalParameters;`
`67`	`67`	`}`
`68`	`68`
`69`		`- List<AnnotatedVarargsParameter> repeatablePositionalParameters() {`
`70`		`- return step1.step0.abstractMethods.repeatablePositionalParameters();`
	`69`	`+ List<AnnotatedVarargsParameter> varargsParameters() {`
	`70`	`+ return step1.step0.abstractMethods.varargsParameters();`
`71`	`71`	`}`
`72`	`72`
`73`		`- Step3 accept(List<Mapping<AnnotatedVarargsParameter>> repeatablePositionalParameters) {`
`74`		`- return new Step3(this, repeatablePositionalParameters);`
	`73`	`+ Step3 accept(List<Mapping<AnnotatedVarargsParameter>> varargsParameters) {`
	`74`	`+ return new Step3(this, varargsParameters);`
`75`	`75`	`}`
`76`	`76`	`}`
`77`	`77`
`78`	`78`	`static final class Step3 {`
`79`	`79`	`private final Step2 step2;`
`80`		`- private final List<Mapping<AnnotatedVarargsParameter>> repeatablePositionalParameters;`
	`80`	`+ private final List<Mapping<AnnotatedVarargsParameter>> varargsParameters;`
`81`	`81`
`82`		`- private Step3(Step2 step2, List<Mapping<AnnotatedVarargsParameter>> repeatablePositionalParameters) {`
	`82`	`+ private Step3(Step2 step2, List<Mapping<AnnotatedVarargsParameter>> varargsParameters) {`
`83`	`83`	`this.step2 = step2;`
`84`		`- this.repeatablePositionalParameters = repeatablePositionalParameters;`
	`84`	`+ this.varargsParameters = varargsParameters;`
`85`	`85`	`}`
`86`	`86`
`87`	`87`	`List<AnnotatedOption> namedOptions() {`
`@@ -101,8 +101,8 @@ public List<Mapping<AnnotatedParameter>> positionalParameters() {`
`101`	`101`	`return step3.step2.positionalParameters;`
`102`	`102`	`}`
`103`	`103`
`104`		`- public List<Mapping<AnnotatedVarargsParameter>> repeatablePositionalParameters() {`
`105`		`- return step3.repeatablePositionalParameters;`
	`104`	`+ public List<Mapping<AnnotatedVarargsParameter>> varargsParameters() {`
	`105`	`+ return step3.varargsParameters;`
`106`	`106`	`}`
`107`	`107`
`108`	`108`	`public CommandRepresentation build() {`
Original file line number	Diff line number	Diff line change
`@@ -36,8 +36,8 @@ SourceElement sourceElement() {`
`36`	`36`	`return sourceElement;`
`37`	`37`	`}`
`38`	`38`
`39`		`- List<Mapping<AnnotatedVarargsParameter>> repeatablePositionalParameters() {`
`40`		`- return contextBuilder.repeatablePositionalParameters();`
	`39`	`+ List<Mapping<AnnotatedVarargsParameter>> varargsParameters() {`
	`40`	`+ return contextBuilder.varargsParameters();`
`41`	`41`	`}`
`42`	`42`
`43`	`43`	`List<Mapping<AnnotatedParameter>> positionalParameters() {`
`@@ -66,7 +66,7 @@ ClassName optType() {`
`66`	`66`	`}`
`67`	`67`
`68`	`68`	`private final Supplier<List<Mapping<?>>> allMappings = memoize(() ->`
`69`		`- Stream.of(namedOptions(), positionalParameters(), repeatablePositionalParameters())`
	`69`	`+ Stream.of(namedOptions(), positionalParameters(), varargsParameters())`
`70`	`70`	`.flatMap(List::stream)`
`71`	`71`	`.collect(toList()));`
`72`	`72`
Original file line number	Diff line number	Diff line change
`@@ -43,7 +43,7 @@ final class CreateModelMethod extends HasCommandRepresentation {`
`43`	`43`	`for (Mapping<AnnotatedOption> c : namedOptions()) {`
`44`	`44`	`code.add(CodeBlock.of(".addOption($L)", optionBlock(c)));`
`45`	`45`	`}`
`46`		`- Stream.of(positionalParameters(), repeatablePositionalParameters())`
	`46`	`+ Stream.of(positionalParameters(), varargsParameters())`
`47`	`47`	`.flatMap(List::stream)`
`48`	`48`	`.forEach(c -> code.add(CodeBlock.of(".addParameter($L)", parameterBlock(c))));`
`49`	`49`	`code.add(CodeBlock.of(".build()"));`
Original file line number	Diff line number	Diff line change
`@@ -38,11 +38,7 @@ final List<Mapping<AnnotatedParameter>> positionalParameters() {`
`38`	`38`	`return commandRepresentation.positionalParameters();`
`39`	`39`	`}`
`40`	`40`
`41`		`- final List<Mapping<AnnotatedVarargsParameter>> repeatablePositionalParameters() {`
`42`		`- return commandRepresentation.repeatablePositionalParameters();`
`43`		`- }`
`44`		`-`
`45`		`- final CommandRepresentation commandRepresentation() {`
`46`		`- return commandRepresentation;`
	`41`	`+ final List<Mapping<AnnotatedVarargsParameter>> varargsParameters() {`
	`42`	`+ return commandRepresentation.varargsParameters();`
`47`	`43`	`}`
`48`	`44`	`}`