Skip to content

Commit afb9f43

Browse files
h908714124h908714124
committed
refactoring
1 parent ad96bbb commit afb9f43

14 files changed

Lines changed: 78 additions & 78 deletions

‎compiler/src/main/java/net/jbock/annotated/AnnotatedMethods.java‎

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -6,11 +6,11 @@
66
public final class AnnotatedMethods {
77

88
private final Step3 step3;
9-
private final List<AnnotatedParameters> repeatablePositionalParameters;
9+
private final List<AnnotatedVarargsParameter> repeatablePositionalParameters;
1010

1111
private AnnotatedMethods(
1212
Step3 step3,
13-
List<AnnotatedParameters> repeatablePositionalParameters) {
13+
List<AnnotatedVarargsParameter> repeatablePositionalParameters) {
1414
this.step3 = step3;
1515
this.repeatablePositionalParameters = repeatablePositionalParameters;
1616
}
@@ -23,7 +23,7 @@ public List<AnnotatedParameter> positionalParameters() {
2323
return step3.positionalParameters;
2424
}
2525

26-
public List<AnnotatedParameters> repeatablePositionalParameters() {
26+
public List<AnnotatedVarargsParameter> repeatablePositionalParameters() {
2727
return repeatablePositionalParameters;
2828
}
2929

@@ -81,7 +81,7 @@ Stream<AnnotatedMethod> annotatedMethods() {
8181
return step2.step1.annotatedMethods.stream();
8282
}
8383

84-
AnnotatedMethods withRepeatablePositionalParameters(List<AnnotatedParameters> repeatablePositionalParameters) {
84+
AnnotatedMethods withRepeatablePositionalParameters(List<AnnotatedVarargsParameter> repeatablePositionalParameters) {
8585
return new AnnotatedMethods(this, repeatablePositionalParameters);
8686
}
8787
}

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

Lines changed: 5 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -55,9 +55,8 @@ public Either<List<ValidationFailure>, AnnotatedMethods> createAnnotatedMethods(
5555
return executableElementsFinder.findExecutableElements()
5656
.map(EnumNames::builder)
5757
.map(builder -> builder.withEnumNames(createEnumNames(builder.methods())))
58-
.flatMap(builder -> builder.methods().stream()
59-
.map(sourceMethod -> createAnnotatedMethod(sourceMethod,
60-
builder.enumNames().get(sourceMethod.simpleName())))
58+
.flatMap(names -> names.methods().stream()
59+
.map(sourceMethod -> createAnnotatedMethod(sourceMethod, names))
6160
.collect(allFailures()))
6261
.map(AnnotatedMethods::builder)
6362
.map(builder -> builder.withNamedOptions(builder.annotatedMethods()
@@ -68,7 +67,7 @@ public Either<List<ValidationFailure>, AnnotatedMethods> createAnnotatedMethods(
6867
.sorted(indexComparator)
6968
.collect(toList())))
7069
.map(builder -> builder.withRepeatablePositionalParameters(builder.annotatedMethods()
71-
.flatMap(instancesOf(AnnotatedParameters.class))
70+
.flatMap(instancesOf(AnnotatedVarargsParameter.class))
7271
.collect(toList())))
7372
.filter(this::validateAtLeastOneParameterInSuperCommand);
7473
}
@@ -102,7 +101,8 @@ private Map<Name, String> createEnumNames(List<Executable> methods) {
102101

103102
private Either<ValidationFailure, AnnotatedMethod> createAnnotatedMethod(
104103
Executable sourceMethod,
105-
String enumName) {
104+
EnumNames enumNames) {
105+
String enumName = enumNames.enumNameFor(sourceMethod.simpleName());
106106
ExecutableElement method = sourceMethod.method();
107107
return util.checkNoDuplicateAnnotations(method, methodLevelAnnotations())
108108
.<Either<ValidationFailure, AnnotatedMethod>>map(Either::left)

compiler/src/main/java/net/jbock/annotated/AnnotatedParameters.java renamed to compiler/src/main/java/net/jbock/annotated/AnnotatedVarargsParameter.java

Lines changed: 7 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -4,26 +4,26 @@
44

55
import java.util.Locale;
66

7-
public final class AnnotatedParameters extends AnnotatedMethod {
7+
public final class AnnotatedVarargsParameter extends AnnotatedMethod {
88

9-
private final ExecutableParameters parameters;
9+
private final ExecutableVarargsParameter parameters;
1010

11-
private AnnotatedParameters(
11+
private AnnotatedVarargsParameter(
1212
String enumName,
13-
ExecutableParameters parameters,
13+
ExecutableVarargsParameter parameters,
1414
String paramLabel) {
1515
super(enumName, paramLabel);
1616
this.parameters = parameters;
1717
}
1818

19-
static AnnotatedParameters createParameters(
20-
ExecutableParameters parameters,
19+
static AnnotatedVarargsParameter createVarargsParameter(
20+
ExecutableVarargsParameter parameters,
2121
String enumName) {
2222
String paramLabel = parameters.paramLabel()
2323
.orElseGet(() -> SnakeName.create(parameters.simpleName())
2424
.snake('_')
2525
.toUpperCase(Locale.US));
26-
return new AnnotatedParameters(enumName, parameters, paramLabel);
26+
return new AnnotatedVarargsParameter(enumName, parameters, paramLabel);
2727
}
2828

2929
@Override

‎compiler/src/main/java/net/jbock/annotated/EnumNames.java‎

Lines changed: 10 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -6,23 +6,23 @@
66

77
final class EnumNames {
88

9-
private final Step1 step1;
9+
private final Builder builder;
1010
private final Map<Name, String> enumNames;
1111

12-
private EnumNames(Step1 step1, Map<Name, String> enumNames) {
13-
this.step1 = step1;
12+
private EnumNames(Builder builder, Map<Name, String> enumNames) {
13+
this.builder = builder;
1414
this.enumNames = enumNames;
1515
}
1616

17-
static Step1 builder(List<Executable> methods) {
18-
return new Step1(methods);
17+
static Builder builder(List<Executable> methods) {
18+
return new Builder(methods);
1919
}
2020

21-
static final class Step1 {
21+
static final class Builder {
2222

2323
private final List<Executable> methods;
2424

25-
private Step1(List<Executable> methods) {
25+
private Builder(List<Executable> methods) {
2626
this.methods = methods;
2727
}
2828

@@ -35,11 +35,11 @@ EnumNames withEnumNames(Map<Name, String> enumNames) {
3535
}
3636
}
3737

38-
Map<Name, String> enumNames() {
39-
return enumNames;
38+
String enumNameFor(Name sourceMethodName) {
39+
return enumNames.get(sourceMethodName);
4040
}
4141

4242
List<Executable> methods() {
43-
return step1.methods;
43+
return builder.methods;
4444
}
4545
}

‎compiler/src/main/java/net/jbock/annotated/Executable.java‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -71,12 +71,12 @@ Executable create(
7171
return new ExecutableParameter(method, (Parameter) annotation, converter);
7272
}
7373
if (annotation instanceof VarargsParameter) {
74-
return new ExecutableParameters(method, (VarargsParameter) annotation, converter);
74+
return new ExecutableVarargsParameter(method, (VarargsParameter) annotation, converter);
7575
}
7676
if (annotation instanceof Parameters) {
7777
messager.printMessage(WARNING,
7878
"@Parameters has been deprecated, use @VarargsParameter instead", method);
79-
return new ExecutableParameters(method, convertLegacyParameters((Parameters) annotation), converter);
79+
return new ExecutableVarargsParameter(method, convertLegacyParameters((Parameters) annotation), converter);
8080
}
8181
throw new AssertionError();
8282
}

compiler/src/main/java/net/jbock/annotated/ExecutableParameters.java renamed to compiler/src/main/java/net/jbock/annotated/ExecutableVarargsParameter.java

Lines changed: 10 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -8,39 +8,39 @@
88
import java.util.List;
99
import java.util.Optional;
1010

11-
import static net.jbock.annotated.AnnotatedParameters.createParameters;
11+
import static net.jbock.annotated.AnnotatedVarargsParameter.createVarargsParameter;
1212
import static net.jbock.common.Constants.optionalString;
1313

14-
final class ExecutableParameters extends Executable {
14+
final class ExecutableVarargsParameter extends Executable {
1515

16-
private final VarargsParameter parameters;
16+
private final VarargsParameter parameter;
1717

18-
ExecutableParameters(
18+
ExecutableVarargsParameter(
1919
ExecutableElement method,
20-
VarargsParameter parameters,
20+
VarargsParameter parameter,
2121
Optional<TypeElement> converter) {
2222
super(method, converter);
23-
this.parameters = parameters;
23+
this.parameter = parameter;
2424
}
2525

2626
@Override
2727
AnnotatedMethod annotatedMethod(
2828
SourceElement sourceElement,
2929
String enumName) {
30-
return createParameters(this, enumName);
30+
return createVarargsParameter(this, enumName);
3131
}
3232

3333
@Override
3434
Optional<String> descriptionKey() {
35-
return optionalString(parameters.descriptionKey());
35+
return optionalString(parameter.descriptionKey());
3636
}
3737

3838
@Override
3939
List<String> description() {
40-
return List.of(parameters.description());
40+
return List.of(parameter.description());
4141
}
4242

4343
Optional<String> paramLabel() {
44-
return optionalString(parameters.paramLabel());
44+
return optionalString(parameter.paramLabel());
4545
}
4646
}

‎compiler/src/main/java/net/jbock/validate/CommandProcessor.java‎

Lines changed: 6 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -26,17 +26,17 @@ public class CommandProcessor {
2626

2727
private final AnnotatedMethodsFactory methodsFactory;
2828
private final SourceElement sourceElement;
29-
private final SourceOptionValidator optionValidator;
30-
private final SourceParameterValidator parameterValidator;
31-
private final SourceParametersValidator parametersValidator;
29+
private final OptionValidator optionValidator;
30+
private final ParameterValidator parameterValidator;
31+
private final VarargsParameterValidator parametersValidator;
3232

3333
@Inject
3434
CommandProcessor(
3535
AnnotatedMethodsFactory methodsFactory,
3636
SourceElement sourceElement,
37-
SourceOptionValidator optionValidator,
38-
SourceParameterValidator parameterValidator,
39-
SourceParametersValidator parametersValidator) {
37+
OptionValidator optionValidator,
38+
ParameterValidator parameterValidator,
39+
VarargsParameterValidator parametersValidator) {
4040
this.methodsFactory = methodsFactory;
4141
this.sourceElement = sourceElement;
4242
this.optionValidator = optionValidator;

‎compiler/src/main/java/net/jbock/validate/ContextBuilder.java‎

Lines changed: 6 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -3,7 +3,7 @@
33
import net.jbock.annotated.AnnotatedMethods;
44
import net.jbock.annotated.AnnotatedOption;
55
import net.jbock.annotated.AnnotatedParameter;
6-
import net.jbock.annotated.AnnotatedParameters;
6+
import net.jbock.annotated.AnnotatedVarargsParameter;
77
import net.jbock.convert.Mapping;
88
import net.jbock.processor.SourceElement;
99
import net.jbock.writing.CommandRepresentation;
@@ -66,20 +66,20 @@ private Step2(Step1 step1, List<Mapping<AnnotatedParameter>> positionalParameter
6666
this.positionalParameters = positionalParameters;
6767
}
6868

69-
List<AnnotatedParameters> repeatablePositionalParameters() {
69+
List<AnnotatedVarargsParameter> repeatablePositionalParameters() {
7070
return step1.step0.abstractMethods.repeatablePositionalParameters();
7171
}
7272

73-
Step3 accept(List<Mapping<AnnotatedParameters>> repeatablePositionalParameters) {
73+
Step3 accept(List<Mapping<AnnotatedVarargsParameter>> repeatablePositionalParameters) {
7474
return new Step3(this, repeatablePositionalParameters);
7575
}
7676
}
7777

7878
static final class Step3 {
7979
private final Step2 step2;
80-
private final List<Mapping<AnnotatedParameters>> repeatablePositionalParameters;
80+
private final List<Mapping<AnnotatedVarargsParameter>> repeatablePositionalParameters;
8181

82-
private Step3(Step2 step2, List<Mapping<AnnotatedParameters>> repeatablePositionalParameters) {
82+
private Step3(Step2 step2, List<Mapping<AnnotatedVarargsParameter>> repeatablePositionalParameters) {
8383
this.step2 = step2;
8484
this.repeatablePositionalParameters = repeatablePositionalParameters;
8585
}
@@ -101,7 +101,7 @@ public List<Mapping<AnnotatedParameter>> positionalParameters() {
101101
return step3.step2.positionalParameters;
102102
}
103103

104-
public List<Mapping<AnnotatedParameters>> repeatablePositionalParameters() {
104+
public List<Mapping<AnnotatedVarargsParameter>> repeatablePositionalParameters() {
105105
return step3.repeatablePositionalParameters;
106106
}
107107

compiler/src/main/java/net/jbock/validate/SourceOptionValidator.java renamed to compiler/src/main/java/net/jbock/validate/OptionValidator.java

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -22,13 +22,13 @@
2222
import static javax.lang.model.type.TypeKind.BOOLEAN;
2323

2424
@ValidateScope
25-
class SourceOptionValidator {
25+
class OptionValidator {
2626

2727
private final MappingFinder mappingFinder;
2828
private final MatchFinder matchFinder;
2929

3030
@Inject
31-
SourceOptionValidator(
31+
OptionValidator(
3232
MappingFinder mappingFinder,
3333
MatchFinder matchFinder) {
3434
this.mappingFinder = mappingFinder;

compiler/src/main/java/net/jbock/validate/SourceParameterValidator.java renamed to compiler/src/main/java/net/jbock/validate/ParameterValidator.java

Lines changed: 9 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -17,38 +17,38 @@
1717
import static io.jbock.util.Eithers.toOptionalList;
1818

1919
@ValidateScope
20-
class SourceParameterValidator {
20+
class ParameterValidator {
2121

2222
private final MappingFinder mappingFinder;
2323

2424
@Inject
25-
SourceParameterValidator(MappingFinder mappingFinder) {
25+
ParameterValidator(MappingFinder mappingFinder) {
2626
this.mappingFinder = mappingFinder;
2727
}
2828

2929
Either<List<ValidationFailure>, ContextBuilder.Step2> wrapPositionalParams(
3030
ContextBuilder.Step1 step) {
3131
return validatePositions(step.positionalParameters())
32-
.flatMap(positionalParameters -> positionalParameters.stream()
32+
.flatMap(parameters -> parameters.stream()
3333
.map(mappingFinder::findMapping)
3434
.collect(allFailures()))
3535
.filter(this::checkNoRequiredAfterOptional)
3636
.map(step::accept);
3737
}
3838

3939
private Either<List<ValidationFailure>, List<AnnotatedParameter>> validatePositions(
40-
List<AnnotatedParameter> positionalParameters) {
40+
List<AnnotatedParameter> parameters) {
4141
List<ValidationFailure> failures = new ArrayList<>();
42-
for (int i = 0; i < positionalParameters.size(); i++) {
43-
AnnotatedParameter sourceParameter = positionalParameters.get(i);
44-
int index = sourceParameter.index();
42+
for (int i = 0; i < parameters.size(); i++) {
43+
AnnotatedParameter parameter = parameters.get(i);
44+
int index = parameter.index();
4545
if (index != i) {
46-
failures.add(sourceParameter.fail("invalid position: expecting " + i + " but found " + index));
46+
failures.add(parameter.fail("invalid position: expecting " + i + " but found " + index));
4747
}
4848
}
4949
return optionalList(failures)
5050
.<Either<List<ValidationFailure>, List<AnnotatedParameter>>>map(Either::left)
51-
.orElseGet(() -> right(positionalParameters));
51+
.orElseGet(() -> right(parameters));
5252
}
5353

5454
/* Left-Optional

0 commit comments

Comments
 (0)