release 1.7

h908714124 · h908714124 · commit eb4c66be3b9b · 2017-05-09T21:11:10.000+02:00
diff --git a/README.md b/README.md
@@ -21,6 +21,7 @@ non-options do not stop option parsing, so options and non-options can be in any
 * Short args can be written `-n1` or `-n 1` style.
 * Long args can be written `--num=1` or `--num 1` style.
 * A long flag is written `--zap`, a short flag `-z`.
+* Grouping is possible, as in 'tar -xzf d.tgz'.
 * "Non-options", like in `rm foo.txt`: Use `@OtherTokens`
 * "End of option scanning", like in `rm -- foo.txt`: Use `@EverythingAfter("--")`
 
@@ -149,7 +150,7 @@ If you're not familiar with `rm`'s `--` option, try `echo >>-f` and deleting the
 <dependency>
   <groupId>com.github.h908714124</groupId>
   <artifactId>jbock</artifactId>
-  <version>1.6</version>
+  <version>1.7</version>
   <scope>provided</scope>
 </dependency>
 ````
diff --git a/core/src/main/java/net/jbock/compiler/Analyser.java b/core/src/main/java/net/jbock/compiler/Analyser.java
@@ -25,7 +25,6 @@
 import static javax.lang.model.element.Modifier.PRIVATE;
 import static javax.lang.model.element.Modifier.PUBLIC;
 import static javax.lang.model.element.Modifier.STATIC;
-import static net.jbock.compiler.Option.constructorArgumentsForJavadoc;
 
 final class Analyser {
 
@@ -56,6 +55,7 @@ final class Analyser {
   private final MethodSpec readOption;
   private final MethodSpec checkConflict;
   private final MethodSpec readArgument;
+  private final MethodSpec removeFirstFlag;
 
   private final FieldSpec longNames;
   private final FieldSpec shortNames;
@@ -83,6 +83,7 @@ private Analyser(Constructor constructor) {
     this.optionMapType = ParameterizedTypeName.get(ClassName.get(Map.class),
         option.optionClass, listOfArgumentType);
     this.readArgument = readArgumentMethod();
+    this.removeFirstFlag = removeFirstFlagMethod();
     this.optMap = FieldSpec.builder(optionMapType, "optMap")
         .addModifiers(PRIVATE, FINAL)
         .build();
@@ -95,7 +96,21 @@ private Analyser(Constructor constructor) {
     this.readOption = readOptionMethod(keysClass, longNames, shortNames, option.optionClass);
     this.checkConflict = checkConflictMethod(optionMapType, option.optionClass, optionTypeClass, optionType);
     this.read = readMethod(keysClass, readOption, readArgument, optionMapType,
-        option.optionClass, optionType, optionTypeClass, checkConflict);
+        option.optionClass, optionType, optionTypeClass, checkConflict, removeFirstFlag);
+  }
+
+  private static MethodSpec removeFirstFlagMethod() {
+    ParameterSpec token = ParameterSpec.builder(STRING, "token").build();
+    return MethodSpec.methodBuilder("removeFirstFlag")
+        .beginControlFlow("if ($N.length() <= 2 || $N.startsWith($S))",
+            token, token, "--")
+        .addStatement("return null")
+        .endControlFlow()
+        .addStatement("return $S + $N.substring(2)", "-", token)
+        .addParameter(token)
+        .addModifiers(PRIVATE, STATIC)
+        .returns(STRING)
+        .build();
   }
 
   private static MethodSpec checkConflictMethod(TypeName optionMapType, ClassName optionClass,
@@ -136,6 +151,7 @@ TypeSpec analyse() {
         .addMethod(readOption)
         .addMethod(readArgument)
         .addMethod(checkConflict)
+        .addMethod(removeFirstFlag)
         .addModifiers(PUBLIC, FINAL)
         .build();
   }
@@ -177,21 +193,10 @@ private MethodSpec parseMethod() {
               read, token, names, optMap, otherTokens, it)
         .endControlFlow()
       .addStatement("return new $T($N, $N, $N)", binderClass, optMap, otherTokens, rest);
-    TypeName originalClass = constructor.enclosingType;
     return MethodSpec.methodBuilder("parse")
         .addParameter(ARGS)
         .addCode(builder.build())
         .addException(IllegalArgumentException.class)
-        .addJavadoc("Parses the command line arguments and performs basic validation.\n" +
-                "\n" +
-                "@param args command line arguments\n" +
-                "@throws $T if the input is invalid or ambiguous\n" +
-                "@return a binder for constructing {@link $T}\n" +
-                "\n" +
-                "@see $T#$T($L)\n",
-            IllegalArgumentException.class,
-            constructor.enclosingType,
-            originalClass, originalClass, constructorArgumentsForJavadoc(constructor))
         .returns(binderClass)
         .addModifiers(PUBLIC, STATIC)
         .build();
@@ -267,7 +272,10 @@ private static MethodSpec readMethod(ClassName keysClass,
                                        MethodSpec readArgument,
                                        TypeName optionMapType,
                                        ClassName optionClass,
-                                       FieldSpec optionType, ClassName optionTypeClass, MethodSpec checkConflict) {
+                                       FieldSpec optionType,
+                                       ClassName optionTypeClass,
+                                       MethodSpec checkConflict,
+                                       MethodSpec removeFirstFlag) {
     ParameterSpec names = ParameterSpec.builder(keysClass, "names").build();
     ParameterSpec optMap = ParameterSpec.builder(optionMapType, "optMap").build();
     ParameterSpec otherTokens = ParameterSpec.builder(STRING_LIST, "otherTokens").build();
@@ -287,12 +295,23 @@ private static MethodSpec readMethod(ClassName keysClass,
         .addStatement("$N($N, $N, $N)", checkConflict, optMap, option, token)
         .addStatement("$T $N = $N.computeIfAbsent($N, $N -> new $T<>())",
             bucket.type, bucket, optMap, option, ignore, ArrayList.class)
-        .beginControlFlow("if ($N.$N == $T.$L)", option, optionType, optionTypeClass, OptionType.FLAG)
-          .add("// add some non-null string to represent the flag\n")
+        .beginControlFlow("while ($N.$N == $T.$L)", option, optionType, optionTypeClass, OptionType.FLAG)
           .addStatement("$N.add($S)", bucket, "t")
-          .addStatement("return")
+          .addStatement("$N = $N($N)", token, removeFirstFlag, token)
+          .beginControlFlow("if ($N == null)", token)
+            .addStatement("break")
+            .endControlFlow()
+          .addStatement("$N = $N($N, $N)", option, readOption, names, token)
+          .beginControlFlow("if ($N == null)", option)
+            .addStatement("throw new $T($S)", IllegalArgumentException.class,
+                "invalid token")
+            .endControlFlow()
+           .addStatement("$N = $N.computeIfAbsent($N, $N -> new $T<>())",
+             bucket, optMap, option, ignore, ArrayList.class)
           .endControlFlow()
-        .addStatement("$N.add($N($N, $N))", bucket, readArgument, token, it);
+        .beginControlFlow("if ($N.type != $T.$L)", option, optionTypeClass, OptionType.FLAG)
+          .addStatement("$N.add($N($N, $N))", bucket, readArgument, token, it)
+        .endControlFlow();
     //@formatter:on
     return MethodSpec.methodBuilder("read")
         .addParameters(Arrays.asList(token, names, optMap, otherTokens, it))
diff --git a/core/src/main/java/net/jbock/compiler/Binder.java b/core/src/main/java/net/jbock/compiler/Binder.java
@@ -59,9 +59,6 @@ TypeSpec define() {
         .addMethod(privateConstructor())
         .addMethod(bindMethod())
         .addMethod(otherTokensMethod())
-        .addJavadoc("Parsed arguments, ready to be passed to the constructor.\n\n" +
-                "@see $T#$T($L)\n", originalClass, originalClass,
-            Option.constructorArgumentsForJavadoc(constructor))
         .build();
   }
 
@@ -91,32 +88,17 @@ private MethodSpec bindMethod() {
       }
     }
     builder.add(");\n");
-    TypeName originalClass = constructor.enclosingType;
-    StringBuilder javadoc = new StringBuilder();
-    javadoc.append("Invokes the constructor.\n")
-        .append("\n");
-    for (TypeName thrownType : constructor.thrownTypes) {
-      javadoc.append("@throws ").append(thrownType.toString()).append("\n");
-    }
-    javadoc.append("@return an instance of {@link $T}\n");
     return MethodSpec.methodBuilder("bind")
         .addCode(builder.build())
         .addExceptions(constructor.thrownTypes)
         .addModifiers(PUBLIC)
-        .addJavadoc(javadoc.toString(), originalClass)
         .returns(constructor.enclosingType)
         .build();
   }
 
   private MethodSpec otherTokensMethod() {
     return MethodSpec.methodBuilder("otherTokens")
         .addStatement("return $N", otherTokens)
-        .addJavadoc("Collection of all unbound tokens.\n" +
-            "Unless @OtherTokens is used in the constructor,\n" +
-            "a good practice is to verify that this list is empty\n" +
-            "before invoking {@link #bind()}.\n" +
-            "\n" +
-            "@return tokens that the parser ignored, an unmodifiable list\n")
         .returns(otherTokens.type)
         .addModifiers(PUBLIC)
         .build();
diff --git a/core/src/main/java/net/jbock/compiler/Option.java b/core/src/main/java/net/jbock/compiler/Option.java
@@ -90,8 +90,7 @@ static String constructorArgumentsForJavadoc(Constructor constructor) {
   }
 
   TypeSpec define() {
-    TypeSpec.Builder builder = TypeSpec.enumBuilder(optionClass)
-        .addJavadoc("The enum constants correspond to the constructor arguments.\n");
+    TypeSpec.Builder builder = TypeSpec.enumBuilder(optionClass);
     for (int i = 0; i < constructor.parameters.size(); i++) {
       Param param = constructor.parameters.get(i);
       String[] desc = getText(param.description);
@@ -153,9 +152,6 @@ private static MethodSpec shortNameMethod() {
     return MethodSpec.methodBuilder(SHORT_NAME.name)
         .addStatement("return $T.toString($N, null)", Objects.class, SHORT_NAME)
         .returns(STRING)
-        .addJavadoc("The short name is exactly one character in length, or null.\n" +
-            "\n" +
-            "@return short name, without the '-'; possibly null\n")
         .addModifiers(PUBLIC)
         .build();
   }
@@ -164,9 +160,6 @@ private static MethodSpec longNameMethod() {
     return MethodSpec.methodBuilder(LONG_NAME.name)
         .addStatement("return $N", LONG_NAME)
         .returns(LONG_NAME.type)
-        .addJavadoc("The long name is at least one character in length, or null.\n" +
-            "\n" +
-            "@return long name, without the '--'; possibly null\n")
         .addModifiers(PUBLIC)
         .build();
   }
@@ -175,15 +168,13 @@ private MethodSpec descriptionMethod() {
     return MethodSpec.methodBuilder(DESCRIPTION.name)
         .addStatement("return $N", DESCRIPTION)
         .returns(DESCRIPTION.type)
-        .addJavadoc("@return description lines\n")
         .addModifiers(PUBLIC)
         .build();
   }
 
   private static MethodSpec descriptionParameterMethod() {
     return MethodSpec.methodBuilder(ARGUMENT_NAME.name)
         .addStatement("return $N", ARGUMENT_NAME)
-        .addJavadoc("@return example parameter name, possibly null\n")
         .returns(ARGUMENT_NAME.type)
         .addModifiers(PUBLIC)
         .build();
@@ -192,7 +183,6 @@ private static MethodSpec descriptionParameterMethod() {
   private MethodSpec typeMethod() {
     return MethodSpec.methodBuilder(optionType.name)
         .addStatement("return $N", optionType)
-        .addJavadoc("@return option type\n")
         .returns(optionType.type)
         .addModifiers(PUBLIC)
         .build();
@@ -242,10 +232,6 @@ private static MethodSpec descriptionBlockMethod() {
         .addParameter(indent)
         .returns(Analyser.STRING)
         .addCode(builder.build())
-        .addJavadoc("Get the argument description.\n" +
-            "\n" +
-            "@param indent number of space characters to indent the description with\n" +
-            "@return printable description\n")
         .build();
   }
 
@@ -264,10 +250,6 @@ private MethodSpec describeMethod() {
         .addModifiers(PUBLIC)
         .returns(Analyser.STRING)
         .addParameter(indent)
-        .addJavadoc("Convenience method to get a formatted description of the argument.\n" +
-            "\n" +
-            "@param indent number of space characters to indent the description with\n" +
-            "@return printable description\n")
         .addCode(codeBlock)
         .build();
   }
@@ -310,9 +292,6 @@ private static MethodSpec describeNamesMethod(FieldSpec optionType, ClassName op
         .addModifiers(PUBLIC)
         .returns(Analyser.STRING)
         .addCode(builder.build())
-        .addJavadoc("Get a basic description of the argument name and type.\n" +
-            "\n" +
-            "@return printable description\n")
         .build();
   }
 }
diff --git a/core/src/main/java/net/jbock/compiler/OptionType.java b/core/src/main/java/net/jbock/compiler/OptionType.java
@@ -15,7 +15,6 @@ static TypeSpec define(ClassName optionTypeClass) {
       builder.addEnumConstant(optionType.name());
     }
     return builder.addModifiers(PUBLIC)
-        .addJavadoc("The possible option types.\n")
         .build();
   }
 }
diff --git a/examples/src/main/java/net/zerobuilder/examples/gradle/GradleMan.java b/examples/src/main/java/net/zerobuilder/examples/gradle/GradleMan.java
@@ -16,6 +16,7 @@ final class GradleMan {
   final List<String> file;
   final String dir;
   final boolean cmos;
+  final boolean verbose;
 
   static final class Foo {
     final String bar;
@@ -41,10 +42,13 @@ static final class Foo {
                 String dir,
             @ShortName('c')
             @Description("cmos flag")
-                boolean cmos) throws IOException, NullPointerException {
+                boolean cmos,
+            @ShortName('v')
+                boolean verbose) throws IOException, NullPointerException {
     this.message = message;
     this.file = file;
     this.dir = dir;
     this.cmos = cmos;
+    this.verbose = verbose;
   }
 }
diff --git a/examples/src/test/java/net/zerobuilder/examples/gradle/GradleManTest.java b/examples/src/test/java/net/zerobuilder/examples/gradle/GradleManTest.java
@@ -12,7 +12,6 @@
 import java.util.stream.Collectors;
 
 import static java.util.Arrays.asList;
-import static java.util.Collections.singletonList;
 import static org.hamcrest.CoreMatchers.nullValue;
 import static org.hamcrest.core.Is.is;
 import static org.junit.Assert.assertThat;
@@ -159,10 +158,39 @@ public void testNonsense() throws Exception {
     assertThat(binder.otherTokens().size(), is(2));
   }
 
+  @Test
+  public void testFlagWithTrailingGarbage() throws Exception {
+    exception.expect(IllegalArgumentException.class);
+    GradleMan_Parser.parse(new String[]{"-c1"});
+  }
+
+  @Test
+  public void testDoubleFlag() throws Exception {
+    GradleMan gradleMan = GradleMan_Parser.parse(new String[]{"-cv"}).bind();
+    assertThat(gradleMan.cmos, is(true));
+    assertThat(gradleMan.verbose, is(true));
+  }
+
+  @Test
+  public void testDoubleFlagWithAttachedOption() throws Exception {
+    GradleMan gradleMan = GradleMan_Parser.parse(new String[]{"-cvmhello"}).bind();
+    assertThat(gradleMan.cmos, is(true));
+    assertThat(gradleMan.verbose, is(true));
+    assertThat(gradleMan.message, is("hello"));
+  }
+
+  @Test
+  public void testDoubleFlagWithDetachedOption() throws Exception {
+    GradleMan gradleMan = GradleMan_Parser.parse(new String[]{"-cvm", "hello"}).bind();
+    assertThat(gradleMan.cmos, is(true));
+    assertThat(gradleMan.verbose, is(true));
+    assertThat(gradleMan.message, is("hello"));
+  }
+
   @Test
   public void testOptions() throws Exception {
     Option[] options = Option.values();
-    assertThat(options.length, is(4));
+    assertThat(options.length, is(5));
     assertThat(Arrays.stream(options)
             .filter(o -> o.type() != OptionType.FLAG)
             .map(Option::longName)
@@ -180,7 +208,7 @@ public void testOptions() throws Exception {
             .map(Option::shortName)
             .filter(Objects::nonNull)
             .collect(Collectors.toSet()),
-        is(new HashSet<>(singletonList("c"))));
+        is(new HashSet<>(asList("c", "v"))));
   }
 
   @Test

Original file line number	Diff line number	Diff line change
`@@ -15,7 +15,6 @@ static TypeSpec define(ClassName optionTypeClass) {`
`15`	`15`	`builder.addEnumConstant(optionType.name());`
`16`	`16`	`}`
`17`	`17`	`return builder.addModifiers(PUBLIC)`
`18`		`- .addJavadoc("The possible option types.\n")`
`19`	`18`	`.build();`
`20`	`19`	`}`
`21`	`20`	`}`