Bean Value API: refactor

- remove ValueContainer
- make supporsType non default
- rename for now ValueConverter to BeanValueConverter

Author: jknack

jooby/src/main/java/io/jooby/Value.java

@@ -10,7 +10,6 @@
 import io.jooby.internal.MissingValue;
 import io.jooby.internal.SingleValue;
 import io.jooby.internal.ValueInjector;
-import io.jooby.spi.ValueContainer;
 
 import javax.annotation.Nonnull;
 import javax.annotation.Nullable;
@@ -53,7 +52,7 @@
  * @since 2.0.0
  * @author edgar
  */
-public interface Value extends Iterable<Value>, ValueContainer {
+public interface Value extends Iterable<Value> {
 
   /**
    * Convert this value to long (if possible).

jooby/src/main/java/io/jooby/internal/ValueInjector.java

@@ -14,7 +14,7 @@
 import io.jooby.TypeMismatchException;
 import io.jooby.Value;
 import io.jooby.internal.reflect.$Types;
-import io.jooby.spi.ValueConverters;
+import io.jooby.spi.BeanValueConverters;
 
 import javax.inject.Inject;
 import javax.inject.Named;
@@ -148,7 +148,7 @@ private static Object resolve(Value scope, Class type)
       throws IllegalAccessException, InvocationTargetException, InstantiationException,
       NoSuchMethodException {
     if (scope.isObject() || scope.isSingle()) {
-      Object o = ValueConverters.getInstance().convert(scope, type);
+      Object o = BeanValueConverters.getInstance().convert(scope, type);
       if (o != null) {
         return o;
       }

…in/java/io/jooby/spi/ValueConverter.java …ava/io/jooby/spi/BeanValueConverter.javajooby/src/main/java/io/jooby/spi/ValueConverter.java renamed to jooby/src/main/java/io/jooby/spi/BeanValueConverter.java jooby/src/main/java/io/jooby/spi/ValueConverter.java renamed to jooby/src/main/java/io/jooby/spi/BeanValueConverter.java

@@ -10,7 +10,7 @@
  * An SPI for value conversion.
  * @author agentgt
  */
-public interface ValueConverter {
+public interface BeanValueConverter {
   /**
    * A short circuit to see if the converter supports the given type.
    *
@@ -20,9 +20,7 @@ public interface ValueConverter {
    * @param type class or interface
    * @return true if the converter can convert for the type
    */
-  default boolean supportsType(@Nonnull Class<?> type) {
-    return true;
-  }
+  boolean supportsType(@Nonnull Class<?> type);
   /**
    * Converts values for {@link Value#to} and friends. Returning null indicates the type is not supported
    * or the converter chose not to do the conversion.
@@ -31,5 +29,5 @@ default boolean supportsType(@Nonnull Class<?> type) {
    * @return <code>null</code> indicates that the converter chose to delegate to other converters down the chain.
    * @throws TypeMismatchException if the converter cannot convert the type and does not want to delegate.
    */
-  @Nullable Object convert(@Nonnull ValueContainer value, @Nonnull Class<?> type) throws TypeMismatchException;
+  @Nullable Object convert(@Nonnull Value value, @Nonnull Class<?> type) throws TypeMismatchException;
 }

…n/java/io/jooby/spi/ValueConverters.java …va/io/jooby/spi/BeanValueConverters.javajooby/src/main/java/io/jooby/spi/ValueConverters.java renamed to jooby/src/main/java/io/jooby/spi/BeanValueConverters.java jooby/src/main/java/io/jooby/spi/ValueConverters.java renamed to jooby/src/main/java/io/jooby/spi/BeanValueConverters.java

@@ -7,28 +7,29 @@
 import javax.annotation.Nullable;
 
 import io.jooby.TypeMismatchException;
+import io.jooby.Value;
 
 /**
- * Contains the {@link ValueConverter}s loaded via the ServiceLoader. It is is a
+ * Contains the {@link BeanValueConverter}s loaded via the ServiceLoader. It is is a
  * singleton and an instance can be retrieved with {@link #getInstance()}. The
  * ValueConverters are stored in an ordered collection and thus resolution of
  * type to be converted is based on the order of the converters.
  *
  * @author agentgt
  *
  */
-public final class ValueConverters {
+public final class BeanValueConverters {
 
   // Allow thread safe adding of ValueConverters.
-  private final Iterable<ValueConverter> valueConverters;
+  private final Iterable<BeanValueConverter> valueConverters;
 
   // Initialization on demand
   private static final class Hidden {
 
-    private static volatile ValueConverters instance = ValueConverters.builder().fromServiceLoader().build();
+    private static volatile BeanValueConverters instance = BeanValueConverters.builder().fromServiceLoader().build();
   }
 
-  private ValueConverters(Iterable<ValueConverter> valueConverters) {
+  private BeanValueConverters(Iterable<BeanValueConverter> valueConverters) {
     super();
     this.valueConverters = valueConverters;
   }
@@ -39,10 +40,10 @@ static Builder builder() {
 
   static final class Builder {
 
-    private final List<ValueConverter> valueConverters = new ArrayList<>();
+    private final List<BeanValueConverter> valueConverters = new ArrayList<>();
 
     Builder fromServiceLoader() {
-      ServiceLoader<ValueConverter> sl = ServiceLoader.load(ValueConverter.class);
+      ServiceLoader<BeanValueConverter> sl = ServiceLoader.load(BeanValueConverter.class);
       // If any failes to load we will fail entirely.
       // The value converters found earlier in the classpath take precedence.
       sl.forEach(this::add);
@@ -57,7 +58,7 @@ Builder fromServiceLoader() {
      * @param vc
      * @return
      */
-    Builder add(ValueConverter vc) {
+    Builder add(BeanValueConverter vc) {
       valueConverters.add(vc);
       return this;
     }
@@ -67,12 +68,12 @@ Builder clear() {
       return this;
     }
 
-    ValueConverters build() {
-      return new ValueConverters(valueConverters);
+    BeanValueConverters build() {
+      return new BeanValueConverters(valueConverters);
     }
 
-    ValueConverters set() {
-      ValueConverters vc = build();
+    BeanValueConverters set() {
+      BeanValueConverters vc = build();
       Hidden.instance = vc;
       return vc;
     }
@@ -89,9 +90,9 @@ ValueConverters set() {
    * @throws TypeMismatchException
    *           failure in a converter
    */
-  public @Nullable Object convert(ValueContainer v, Class<?> c) throws TypeMismatchException {
+  public @Nullable Object convert(Value v, Class<?> c) throws TypeMismatchException {
     Object result = null;
-    for (ValueConverter vc : valueConverters) {
+    for (BeanValueConverter vc : valueConverters) {
       if (vc.supportsType(c)) {
         result = vc.convert(v, c);
         if (result != null) {
@@ -107,8 +108,8 @@ ValueConverters set() {
    *
    * @return the shared singleton used by Jooby
    */
-  public static ValueConverters getInstance() {
-    return ValueConverters.Hidden.instance;
+  public static BeanValueConverters getInstance() {
+    return BeanValueConverters.Hidden.instance;
   }
 
 }

jooby/src/main/java/io/jooby/spi/ValueContainer.java

@@ -4,35 +4,44 @@
 
 import java.util.function.Consumer;
 
+import io.jooby.TypeMismatchException;
+import io.jooby.Value;
 import org.junit.jupiter.api.AfterAll;
 import org.junit.jupiter.api.Test;
 
 import io.jooby.MissingValueException;
 import io.jooby.QueryString;
 import io.jooby.internal.UrlParser;
 
-class ValueConvertersTest {
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+
+public class BeanValueConvertersTest {
 
   @AfterAll
   static void restoreFromServiceLoader() {
     // Restore ValueConvert list for other unit tests.
-    ValueConverters.builder().fromServiceLoader().set();
+    BeanValueConverters.builder().fromServiceLoader().set();
   }
 
   @Test
   void testConvert() {
-    ValueConverters.builder().add((value, type) -> {
-      if (type == MyValue.class) {
+    BeanValueConverters.builder().add(new BeanValueConverter() {
+      @Override public boolean supportsType(@Nonnull Class<?> type) {
+        return type == MyValue.class;
+      }
+
+      @Nullable @Override public Object convert(@Nonnull Value value,
+          @Nonnull Class<?> type) throws TypeMismatchException {
         MyValue mv = new MyValue();
         // we have chosen simple parameters names to make sure we don't get a
         // false positve
         // from the reflection converter.
         mv.name = value.get("n").value();
         // TODO: ValueContainer probably should have primitive convert methods.
-        mv.order = Integer.parseInt(value.get("o").value());
+        mv.order = value.get("o").intValue();
         return mv;
       }
-      return null;
     }).set();
     queryString("n=stuff&o=1", queryString -> {
       MyValue mv = queryString.to(MyValue.class);