Added ValueConverter SPI

Author: agentgt

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

@@ -10,6 +10,7 @@
 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;
@@ -52,7 +53,7 @@
  * @since 2.0.0
  * @author edgar
  */
-public interface Value extends Iterable<Value> {
+public interface Value extends Iterable<Value>, ValueContainer {
 
   /**
    * Convert this value to long (if possible).

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

@@ -14,6 +14,7 @@
 import io.jooby.TypeMismatchException;
 import io.jooby.Value;
 import io.jooby.internal.reflect.$Types;
+import io.jooby.spi.ValueConverters;
 
 import javax.inject.Inject;
 import javax.inject.Named;
@@ -147,6 +148,10 @@ 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);
+      if (o != null) {
+        return o;
+      }
       return newInstance(type, scope);
     } else if (scope.isMissing()) {
       if (type.isPrimitive()) {

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

@@ -1,6 +1,27 @@
 package io.jooby.spi;
 
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
 
-public interface ValueConverter {
+import io.jooby.TypeMismatchException;
+import io.jooby.Value;
 
+public interface ValueConverter {
+  /**
+   * This defaults to true to allow a functional interface.
+   * @param type
+   * @return
+   */
+  default boolean supportsType(@Nonnull Class<?> type) {
+    return true;
+  }
+  /**
+   * 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.
+   * @param value
+   * @param 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;
 }

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

@@ -1,6 +1,70 @@
 package io.jooby.spi;
 
+import java.util.ServiceLoader;
+import java.util.concurrent.CopyOnWriteArrayList;
 
-public class ValueConverters {
+import javax.annotation.Nullable;
+
+import io.jooby.TypeMismatchException;
+
+public final class ValueConverters {
+  // Allow thread safe adding of ValueConverters.
+  private final CopyOnWriteArrayList<ValueConverter> valueConverters;
+  
+  // Initialization on demand
+  private static final class Hidden {
+    private static final ValueConverters INSTANCE = ValueConverters.create().fromServiceLoader();
+  }
+  
+  private ValueConverters(CopyOnWriteArrayList<ValueConverter> valueConverters) {
+    super();
+    this.valueConverters = valueConverters;
+  }
+  
+  static ValueConverters create() {
+    return new ValueConverters(new CopyOnWriteArrayList<>());
+  }
+  
+  public @Nullable Object convert(ValueContainer v, Class<?> c) throws TypeMismatchException {
+    Object result = null;
+    for (ValueConverter vc : valueConverters) {
+      if (vc.supportsType(c)) {
+        result = vc.convert(v, c);
+        if (result != null) {
+          return result;
+        }
+      }
+    }
+    return result;
+  }
+  
+  final ValueConverters fromServiceLoader() {
+    ServiceLoader<ValueConverter> sl = ServiceLoader.load(ValueConverter.class);
+    //If any failes to load we will fail entirely.
+    //The value converters found earlier in the classpath take precedence.
+    sl.forEach(this::add);
+    return this;
+  }
+  /**
+   * You can add value converters programmatic. For now its protected.
+   * Its also to aid unit testing since serviceloader is inherently static singleton.
+   * @param vc
+   * @return
+   */
+  /* private */ final ValueConverters add(ValueConverter vc) {
+    valueConverters.add(vc);
+    return this;
+  }
+  
+  final ValueConverters clear() {
+    valueConverters.clear();
+    return this;
+  }
+  
+  
+  
+  public static final ValueConverters getInstance() {
+    return ValueConverters.Hidden.INSTANCE;
+  }
 
 }

jooby/src/test/java/io/jooby/spi/ValueConvertersTest.java

@@ -0,0 +1,66 @@
+package io.jooby.spi;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+import java.util.function.Consumer;
+
+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 {
+
+  @AfterAll
+  static void restoreFromServiceLoader() {
+    //Restore ValueConvert list for other unit tests.
+    ValueConverters.getInstance().clear().fromServiceLoader();
+  }
+  
+  @Test
+  void testConvert() {
+    ValueConverters.getInstance()
+      .clear()
+      .add((value, type) -> { 
+      if (type == MyValue.class) {
+        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());
+        return mv;
+      }
+      return null;
+    });
+    queryString("n=stuff&o=1", queryString -> {
+      MyValue mv = queryString.to(MyValue.class);
+      assertEquals("stuff", mv.name);
+      assertEquals(1, mv.order);
+    });
+    queryString("n=stuff&missingOrder=1", queryString -> {
+      try {
+        queryString.to(MyValue.class);
+        fail();
+      }
+      catch (MissingValueException mve) {
+        assertEquals("Missing value: 'o'", mve.getMessage());
+      }
+    });
+  }
+  
+  static class MyValue {
+    public String name;
+    public int order;
+  }
+  
+  
+  
+  private void queryString(String queryString, Consumer<QueryString> consumer) {
+    consumer.accept(UrlParser.queryString(queryString));
+  }
+
+}