add name to Route.Mapper (helps debugging) fix #384

Author: jknack

coverage-report/src/test/java/org/jooby/issues/Issue384a.java

@@ -0,0 +1,24 @@
+package org.jooby.issues;
+
+import org.jooby.Route;
+import org.jooby.test.ServerFeature;
+import org.junit.Test;
+
+public class Issue384a extends ServerFeature {
+
+  {
+
+    mapper(Route.Mapper.create("counter", (final Integer v) -> v + 1));
+    mapper(Route.Mapper.create("counter", (final Integer v) -> v + 1));
+
+    get("/counter", () -> 1);
+  }
+
+  @Test
+  public void shouldIgnoreMapperWithSameName() throws Exception {
+    request()
+        .get("/counter")
+        .expect("2");
+  }
+
+}

coverage-report/src/test/java/org/jooby/issues/Issue384b.java

@@ -0,0 +1,26 @@
+package org.jooby.issues;
+
+import org.jooby.test.ServerFeature;
+import org.junit.Test;
+
+public class Issue384b extends ServerFeature {
+
+  {
+
+    mapper(((final Integer value) -> value * 2));
+
+    mapper((v -> Integer.parseInt(v.toString())));
+
+    get("/4", () -> {
+      return "2";
+    });
+  }
+
+  @Test
+  public void shouldStackOrChainMapper() throws Exception {
+    request()
+        .get("/4")
+        .expect("4");
+  }
+
+}

jooby-mongodb-rx/src/main/java/org/jooby/mongodb/MongoRx.java

@@ -403,15 +403,15 @@ public void configure(final Env env, final Config conf, final Binder binder) {
 
   @SuppressWarnings("rawtypes")
   static Route.Mapper mapper() {
-    return v -> Match(v).of(
+    return Route.Mapper.create("mongo-rx", v -> Match(v).of(
         Case(instanceOf(FindObservable.class), m -> m.toObservable().toList()),
         Case(instanceOf(ListCollectionsObservable.class), m -> m.toObservable().toList()),
         Case(instanceOf(ListDatabasesObservable.class), m -> m.toObservable().toList()),
         Case(instanceOf(AggregateObservable.class), m -> m.toObservable().toList()),
         Case(instanceOf(DistinctObservable.class), m -> m.toObservable().toList()),
         Case(instanceOf(MapReduceObservable.class), m -> m.toObservable().toList()),
         Case(instanceOf(MongoObservable.class), m -> m.toObservable()),
-        Case($(), v));
+        Case($(), v)));
   }
 
   static MongoClientSettings.Builder settings(final ConnectionString cstr, final Config conf) {

jooby-reactor/src/main/java/org/jooby/reactor/Reactor.java

@@ -263,7 +263,7 @@ public static Route.Mapper<Object> reactor() {
 
   @SuppressWarnings("unchecked")
   private static Route.Mapper<Object> reactor(final Optional<Supplier<Scheduler>> subscribeOn) {
-    return value -> Match(value).of(
+    return Route.Mapper.create("reactor", value -> Match(value).of(
         /** Flux: */
         Case(instanceOf(Flux.class),
             it -> new Deferred(deferred -> subscribeOn
@@ -277,7 +277,7 @@ private static Route.Mapper<Object> reactor(final Optional<Supplier<Scheduler>>
                 .orElse(it)
                 .consume(deferred::set, deferred::set))),
         /** Ignore */
-        Case($(), value));
+        Case($(), value)));
   }
 
   @Override

jooby-rxjava/src/main/java/org/jooby/rx/Rx.java

@@ -350,7 +350,7 @@ public static Route.Mapper<Object> rx(final Supplier<Scheduler> subscribeOn) {
 
   @SuppressWarnings("unchecked")
   private static Route.Mapper<Object> rx(final Optional<Supplier<Scheduler>> subscribeOn) {
-    return value -> Match(value).of(
+    return Route.Mapper.create("rx", value -> Match(value).of(
         /** Observable : */
         Case(instanceOf(Observable.class),
             it -> new Deferred(deferred -> subscribeOn
@@ -370,7 +370,7 @@ private static Route.Mapper<Object> rx(final Optional<Supplier<Scheduler>> subsc
                 .orElse(it)
                 .subscribe(new DeferredSubscriber(deferred)))),
         /** Ignore */
-        Case($(), value));
+        Case($(), value)));
   }
 
   @Override

jooby/src/main/java/org/jooby/Jooby.java

@@ -637,6 +637,9 @@ public EnvDep(final Predicate<String> predicate, final Consumer<Config> callback
   @SuppressWarnings("rawtypes")
   private Mapper mapper;
 
+  /** Don't add same mapper twice . */
+  private Set<String> mappers = new HashSet<>();
+
   public Jooby() {
     this(null);
   }
@@ -3547,11 +3550,14 @@ public void start(final String[] args, final Consumer<List<Route.Definition>> ro
   }
 
   @Override
-  @SuppressWarnings({"rawtypes", "unchecked" })
-  public Jooby mapper(final Mapper mapper) {
-    this.mapper = Optional.ofNullable(this.mapper)
-        .map(it -> Route.Mapper.compose(it, mapper))
-        .orElse(mapper);
+  @SuppressWarnings("unchecked")
+  public Jooby mapper(final Mapper<?> mapper) {
+    requireNonNull(mapper, "Mapper is required.");
+    if (mappers.add(mapper.name())) {
+      this.mapper = Optional.ofNullable(this.mapper)
+          .map(next -> Route.Mapper.chain(mapper, next))
+          .orElse((Mapper<Object>) mapper);
+    }
     return this;
   }
 

jooby/src/main/java/org/jooby/Route.java

@@ -41,13 +41,16 @@
 import org.jooby.internal.RouteMatcher;
 import org.jooby.internal.RoutePattern;
 
+import com.google.common.base.CaseFormat;
 import com.google.common.base.Strings;
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.Lists;
 import com.google.common.primitives.Primitives;
 import com.google.inject.Key;
 import com.google.inject.TypeLiteral;
 
+import javaslang.CheckedFunction1;
+
 /**
  * Routes are a key concept in Jooby. Routes are executed in the same order they are defined
  * (even for Mvc Routes).
@@ -273,14 +276,56 @@ public interface Route {
    */
   interface Mapper<T> {
 
-     @SuppressWarnings({"rawtypes", "unchecked" })
-    static Mapper<Object> compose(final Mapper it, final Mapper next) {
-      return v -> {
-        Object m = it.map(v);
-        return m == v ? next.map(v) : m;
+    /**
+     * Produces a new mapper by combining the two mapper into one.
+     *
+     * @param it The first mapper to apply.
+     * @param next The second mapper to apply.
+     * @return A new mapper.
+     */
+    @SuppressWarnings({"rawtypes", "unchecked" })
+    static Mapper<Object> chain(final Mapper it, final Mapper next) {
+      return create(it.name() + ">" + next.name(), v -> next.map(it.map(v)));
+    }
+
+    /**
+     * Creates a new named mapper (just syntax suggar for creating a new mapper).
+     *
+     * @param name Mapper's name.
+     * @param fn Map function.
+     * @return A new mapper.
+     */
+    static <T> Mapper<T> create(final String name, final CheckedFunction1<T, Object> fn) {
+      return new Route.Mapper<T>() {
+        @Override
+        public String name() {
+          return name;
+        }
+
+        @Override
+        public Object map(final T value) throws Throwable {
+          return fn.apply(value);
+        }
+
+        @Override
+        public String toString() {
+          return name();
+        }
       };
     }
 
+    /**
+     * @return Mapper's name.
+     */
+    default String name() {
+      String name = Optional.ofNullable(Strings.emptyToNull(getClass().getSimpleName()))
+          .orElseGet(() -> {
+            String classname = getClass().getName();
+            return classname.substring(classname.lastIndexOf('.') + 1);
+          });
+      return CaseFormat.UPPER_CAMEL.to(CaseFormat.LOWER_HYPHEN, name);
+    }
+
     /**
      * Map the type to something else.
      *
@@ -1341,7 +1386,7 @@ public String toString() {
     private Route asRoute(final String method, final RouteMatcher matcher,
         final List<MediaType> produces) {
       return new RouteImpl(filter, this, method, matcher.path(), produces,
-        matcher.vars(), mapper);
+          matcher.vars(), mapper);
     }
 
   }

jooby/src/main/java/org/jooby/Routes.java

@@ -2469,17 +2469,16 @@ Route.Collection complete(String method, String pattern, Route.Complete handler,
    *
    * <pre>{@code
    * {
-   *   mapper(Rx.rx());
+   *   mapper((Integer v) -> v * 2);
    *
-   *   mapper(Reactor.reactor());
-   *
-   *   get("/rx", () -> Observable.just("reactive"));
-   *
-   *   get("/flux", () -> Flux.just("reactive"));
+   *   mapper(v -> Integer.parseInt(v.toString()));
    *
+   *   get("/four", () -> "2");
    * }
    * }</pre>
    *
+   * A call to <code>/four</code> outputs <code>4</code>
+   *
    * @param mapper
    * @return This instance.
    */

jooby/src/test/java/org/jooby/issues/Issue384.java

@@ -0,0 +1,51 @@
+package org.jooby.issues;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+import org.jooby.Route;
+import org.jooby.Route.Mapper;
+import org.junit.Test;
+
+public class Issue384 {
+
+  static class M implements Route.Mapper<Integer> {
+
+    @Override
+    public Object map(final Integer value) throws Throwable {
+      return value;
+    }
+
+  }
+
+  @Test
+  public void defaultRouteMapperName() {
+    Route.Mapper<Integer> intMapper = (final Integer v) -> v * 2;
+    assertTrue(intMapper.name().startsWith("issue384"));
+
+    assertEquals("m", new M().name());
+
+    assertTrue(new Route.Mapper<String>() {
+      @Override
+      public Object map(final String value) throws Throwable {
+        return value;
+      };
+    }.name().startsWith("issue384"));
+  }
+
+  @Test
+  public void routeFactory() {
+    Mapper<Integer> intMapper = Route.Mapper.create("x", (final Integer v) -> v * 2);
+    assertEquals("x", intMapper.name());
+    assertEquals("x", intMapper.toString());
+  }
+
+  @Test
+  public void chain() throws Throwable {
+    Mapper<Integer> intMapper = Route.Mapper.create("int", (final Integer v) -> v * 2);
+    Mapper<String> strMapper = Route.Mapper.create("str", v -> "{" + v + "}");
+    assertEquals("int>str", Route.Mapper.chain(intMapper, strMapper).name());
+    assertEquals("str>int", Route.Mapper.chain(strMapper, intMapper).name());
+    assertEquals(8, Route.Mapper.chain(intMapper, intMapper).map(2));
+  }
+}