no skew for non simple kind

Author: h908714124

core/src/main/java/net/jbock/coerce/CoercionProvider.java

@@ -19,6 +19,7 @@
 import java.util.Map;
 
 import static javax.lang.model.element.Modifier.FINAL;
+import static net.jbock.coerce.CoercionKind.SIMPLE;
 import static net.jbock.coerce.CoercionKind.findKind;
 import static net.jbock.coerce.MapperClassValidator.validateMapperClass;
 import static net.jbock.coerce.MapperCoercion.mapperInit;
@@ -132,7 +133,7 @@ private Coercion handleMapper(
     TypeName mapperType = TypeName.get(mapperClass.asType());
     ParameterSpec mapperParam = ParameterSpec.builder(mapperType, snakeToCamel(paramName) + "Mapper").build();
     TriggerKind tk = trigger(sourceMethod.getReturnType());
-    MapperSkew skew = mapperSkew(tk.trigger);
+    MapperSkew skew = mapperSkew(tk);
     if (skew != null) {
       validateMapperClass(mapperClass, skew.mapperReturnType);
       return coercions.get(skew.baseType).getCoercion(field, tk.kind)
@@ -143,8 +144,11 @@ private Coercion handleMapper(
     }
   }
 
-  private MapperSkew mapperSkew(TypeMirror mirror) {
-    TypeName input = TypeName.get(mirror);
+  private MapperSkew mapperSkew(TriggerKind tk) {
+    if (tk.kind != SIMPLE) {
+      return null;
+    }
+    TypeName input = TypeName.get(tk.trigger);
     if (input.isPrimitive()) {
       if (!coercions.containsKey(input)) {
         return null;

core/src/main/java/net/jbock/coerce/ObjectByteCoercion.java

@@ -1,6 +1,6 @@
 package net.jbock.coerce;
 
-class ObjectByteCoercion extends BasicCharacterCoercion {
+class ObjectByteCoercion extends BasicByteCoercion {
 
   ObjectByteCoercion() {
     super(Byte.class);

core/src/test/java/net/jbock/compiler/ProcessorTest.java

@@ -511,10 +511,10 @@ void mapperValid() {
     List<String> sourceLines = withImports(
         "@CommandLineArguments",
         "abstract class ValidArguments {",
-        "  @Parameter(mappedBy = Mapper.class) abstract int number();",
-        "  static class Mapper implements Function<String, Integer> {",
-        "    public Integer apply(String s) {",
-        "      return 1;",
+        "  @Parameter(mappedBy = Mapper.class) abstract List<OptionalInt> numbers();",
+        "  static class Mapper implements Function<String, OptionalInt> {",
+        "    public OptionalInt apply(String s) {",
+        "      return OptionalInt.of(1);",
         "    }",
         "  }",
         "}");

examples/src/main/java/net/jbock/examples/CustomMapperArguments.java

@@ -51,7 +51,7 @@ abstract class CustomMapperArguments {
   @PositionalParameter(mappedBy = BooleanMapper.class)
   abstract List<Boolean> booleanList();
 
-  @PositionalParameter(mappedBy = OptionalIntMapper.class)
+  @Parameter(mappedBy = OptionalIntMapper.class)
   abstract List<OptionalInt> optionalInts();
 
   @Parameter(mappedBy = BooleanMapper.class)
@@ -117,11 +117,10 @@ static class OptionalIntMapper implements Function<String, OptionalInt> {
 
     @Override
     public OptionalInt apply(String s) {
-      try {
-        return OptionalInt.of(Integer.parseInt(s));
-      } catch (NumberFormatException e) {
+      if (s.isEmpty()) {
         return OptionalInt.empty();
       }
+      return OptionalInt.of(Integer.parseInt(s));
     }
   }
 

examples/src/main/java/net/jbock/examples/PrimitiveArguments.java

@@ -0,0 +1,30 @@
+package net.jbock.examples;
+
+import net.jbock.CommandLineArguments;
+import net.jbock.Parameter;
+
+@CommandLineArguments
+abstract class PrimitiveArguments {
+
+  @Parameter(shortName = 'B')
+  abstract byte simpleByte();
+
+  @Parameter(shortName = 'S')
+  abstract short simpleShort();
+
+  @Parameter(shortName = 'I')
+  abstract int simpleInt();
+
+  @Parameter(shortName = 'L')
+  abstract long simpleLong();
+
+  @Parameter(shortName = 'F')
+  abstract float simpleFloat();
+
+  @Parameter(shortName = 'D')
+  abstract double simpleDouble();
+
+  @Parameter(shortName = 'C')
+  abstract char simpleChar();
+
+}

examples/src/test/java/net/jbock/examples/CustomMapperArgumentsTest.java

@@ -31,6 +31,10 @@ void success() {
         "--anInt", "50",
         "--notFlag", "true",
         "--integerList", "1,2,3,4",
+        "--optionalInts", "1",
+        "--optionalInts", "",
+        "--optionalInts", "3",
+        "--optionalInts", "4",
         "--enumSet", "FOO",
         "true", "false", "true",
         "--stringArray", "A",
@@ -43,6 +47,8 @@ void success() {
     assertEquals(Arrays.asList(true, false, true), parsed.booleanList());
     assertEquals(OptionalInt.of(51), parsed.anOptionalInt());
     assertEquals(Arrays.asList(1, 2, 3, 4), parsed.integerList().orElseThrow(AssertionFailedError::new));
+    assertEquals(Arrays.asList(OptionalInt.of(1), OptionalInt.empty(), OptionalInt.of(3), OptionalInt.of(4)),
+        parsed.optionalInts());
     assertEquals(singleton(MyEnum.FOO), parsed.enumSet().orElseThrow(AssertionFailedError::new));
     assertArrayEquals(new String[]{"A"}, parsed.stringArray().orElseThrow(AssertionFailedError::new));
     assertTrue(parsed.notFlag());
@@ -88,6 +94,8 @@ void testPrint() {
         "",
         "  --enumSet <enum_set>",
         "",
+        "  --optionalInts <optional_ints...>",
+        "",
         "  --notFlag <NOT_FLAG>",
         "",
         "  --help",

examples/src/test/java/net/jbock/examples/PrimitiveArgumentsTest.java

@@ -0,0 +1,31 @@
+package net.jbock.examples;
+
+import net.jbock.examples.fixture.ParserTestFixture;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+class PrimitiveArgumentsTest {
+
+  private ParserTestFixture<PrimitiveArguments> f =
+      ParserTestFixture.create(PrimitiveArguments_Parser.create());
+
+  @Test
+  void simpleTest() {
+    PrimitiveArguments parsed = f.parse(
+        "-B", "1",
+        "-S", "1",
+        "-I", "1",
+        "-L", "1",
+        "-F", "1",
+        "-D", "1",
+        "-C", "A");
+    assertEquals(1, parsed.simpleByte());
+    assertEquals(1, parsed.simpleShort());
+    assertEquals(1, parsed.simpleInt());
+    assertEquals(1, parsed.simpleLong());
+    assertEquals(1, parsed.simpleFloat());
+    assertEquals(1, parsed.simpleDouble());
+    assertEquals('A', parsed.simpleChar());
+  }
+}