Route with lambdas (functional methods)

ninja-core/src/main/java/ninja/ControllerMethods.java

@@ -0,0 +1,182 @@
+/*
+ * Copyright 2016 ninjaframework.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package ninja;
+
+import java.io.Serializable;
+
+/**
+ * Functional interfaces for Ninja controller methods accepting up to X
+ * number of arguments with type inference.
+ */
+public class ControllerMethods {
+
+    /**
+     * Marker interface that all functional interfaces will extend.  Useful for
+     * simple validation an object is a ControllerMethod.
+     */
+    static public interface ControllerMethod extends Serializable { }
+
+    @FunctionalInterface
+    static public interface ControllerMethod0 extends ControllerMethod {
+        Result apply() throws Exception;
+    }
+
+    @FunctionalInterface
+    static public interface ControllerMethod1<A> extends ControllerMethod {
+        Result apply(A a) throws Exception;
+    }
+
+    @FunctionalInterface
+    static public interface ControllerMethod2<A,B> extends ControllerMethod {
+        Result apply(A a, B b) throws Exception;
+    }
+
+    @FunctionalInterface
+    static public interface ControllerMethod3<A,B,C> extends ControllerMethod {
+        Result apply(A a, B b, C c) throws Exception;
+    }
+
+    @FunctionalInterface
+    static public interface ControllerMethod4<A,B,C,D> extends ControllerMethod {
+        Result apply(A a, B b, C c, D d) throws Exception;
+    }
+
+    @FunctionalInterface
+    static public interface ControllerMethod5<A,B,C,D,E> extends ControllerMethod {
+        Result apply(A a, B b, C c, D d, E e) throws Exception;
+    }
+
+    @FunctionalInterface
+    static public interface ControllerMethod6<A,B,C,D,E,F> extends ControllerMethod {
+        Result apply(A a, B b, C c, D d, E e, F f) throws Exception;
+    }
+
+    @FunctionalInterface
+    static public interface ControllerMethod7<A,B,C,D,E,F,G> extends ControllerMethod {
+        Result apply(A a, B b, C c, D d, E e, F f, G g) throws Exception;
+    }
+
+    @FunctionalInterface
+    static public interface ControllerMethod8<A,B,C,D,E,F,G,H> extends ControllerMethod {
+        Result apply(A a, B b, C c, D d, E e, F f, G g, H h) throws Exception;
+    }
+
+    @FunctionalInterface
+    static public interface ControllerMethod9<A,B,C,D,E,F,G,H,I> extends ControllerMethod {
+        Result apply(A a, B b, C c, D d, E e, F f, G g, H h, I i) throws Exception;
+    }
+
+    @FunctionalInterface
+    static public interface ControllerMethod10<A,B,C,D,E,F,G,H,I,J> extends ControllerMethod {
+        Result apply(A a, B b, C c, D d, E e, F f, G g, H h, I i, J j) throws Exception;
+    }
+
+    @FunctionalInterface
+    static public interface ControllerMethod11<A,B,C,D,E,F,G,H,I,J,K> extends ControllerMethod {
+        Result apply(A a, B b, C c, D d, E e, F f, G g, H h, I i, J j, K k) throws Exception;
+    }
+
+    @FunctionalInterface
+    static public interface ControllerMethod12<A,B,C,D,E,F,G,H,I,J,K,L> extends ControllerMethod {
+        Result apply(A a, B b, C c, D d, E e, F f, G g, H h, I i, J j, K k, L l) throws Exception;
+    }
+
+    @FunctionalInterface
+    static public interface ControllerMethod13<A,B,C,D,E,F,G,H,I,J,K,L,M> extends ControllerMethod {
+        Result apply(A a, B b, C c, D d, E e, F f, G g, H h, I i, J j, K k, L l, M m) throws Exception;
+    }
+
+    @FunctionalInterface
+    static public interface ControllerMethod14<A,B,C,D,E,F,G,H,I,J,K,L,M,N> extends ControllerMethod {
+        Result apply(A a, B b, C c, D d, E e, F f, G g, H h, I i, J j, K k, L l, M m, N n) throws Exception;
+    }
+
+    @FunctionalInterface
+    static public interface ControllerMethod15<A,B,C,D,E,F,G,H,I,J,K,L,M,N,O> extends ControllerMethod {
+        Result apply(A a, B b, C c, D d, E e, F f, G g, H h, I i, J j, K k, L l, M m, N n, O o) throws Exception;
+    }
+
+    // if you need more than 15 arguments then we recommend using the
+    // legacy Class, methodName strategy
+
+    // helper methods to allow classes to accept `ControllerMethod` but still
+    // have the compiler create the correct functional method under-the-hood
+
+    static public ControllerMethod0 of(ControllerMethod0 functionalMethod) {
+        return functionalMethod;
+    }
+
+    static public <A> ControllerMethod1<A> of(ControllerMethod1<A> functionalMethod) {
+        return functionalMethod;
+    }
+
+    static public <A,B> ControllerMethod2<A,B> of(ControllerMethod2<A,B> functionalMethod) {
+        return functionalMethod;
+    }
+
+    static public <A,B,C> ControllerMethod3<A,B,C> of(ControllerMethod3<A,B,C> functionalMethod) {
+        return functionalMethod;
+    }
+
+    static public <A,B,C,D> ControllerMethod4<A,B,C,D> of(ControllerMethod4<A,B,C,D> functionalMethod) {
+        return functionalMethod;
+    }
+
+    static public <A,B,C,D,E> ControllerMethod5<A,B,C,D,E> of(ControllerMethod5<A,B,C,D,E> functionalMethod) {
+        return functionalMethod;
+    }
+
+    static public <A,B,C,D,E,F> ControllerMethod6<A,B,C,D,E,F> of(ControllerMethod6<A,B,C,D,E,F> functionalMethod) {
+        return functionalMethod;
+    }
+
+    static public <A,B,C,D,E,F,G> ControllerMethod7<A,B,C,D,E,F,G> of(ControllerMethod7<A,B,C,D,E,F,G> functionalMethod) {
+        return functionalMethod;
+    }
+
+    static public <A,B,C,D,E,F,G,H> ControllerMethod8<A,B,C,D,E,F,G,H> of(ControllerMethod8<A,B,C,D,E,F,G,H> functionalMethod) {
+        return functionalMethod;
+    }
+
+    static public <A,B,C,D,E,F,G,H,I> ControllerMethod9<A,B,C,D,E,F,G,H,I> of(ControllerMethod9<A,B,C,D,E,F,G,H,I> functionalMethod) {
+        return functionalMethod;
+    }
+
+    static public <A,B,C,D,E,F,G,H,I,J> ControllerMethod10<A,B,C,D,E,F,G,H,I,J> of(ControllerMethod10<A,B,C,D,E,F,G,H,I,J> functionalMethod) {
+        return functionalMethod;
+    }
+
+    static public <A,B,C,D,E,F,G,H,I,J,K> ControllerMethod11<A,B,C,D,E,F,G,H,I,J,K> of(ControllerMethod11<A,B,C,D,E,F,G,H,I,J,K> functionalMethod) {
+        return functionalMethod;
+    }
+
+    static public <A,B,C,D,E,F,G,H,I,J,K,L> ControllerMethod12<A,B,C,D,E,F,G,H,I,J,K,L> of(ControllerMethod12<A,B,C,D,E,F,G,H,I,J,K,L> functionalMethod) {
+        return functionalMethod;
+    }
+
+    static public <A,B,C,D,E,F,G,H,I,J,K,L,M> ControllerMethod13<A,B,C,D,E,F,G,H,I,J,K,L,M> of(ControllerMethod13<A,B,C,D,E,F,G,H,I,J,K,L,M> functionalMethod) {
+        return functionalMethod;
+    }
+
+    static public <A,B,C,D,E,F,G,H,I,J,K,L,M,N> ControllerMethod14<A,B,C,D,E,F,G,H,I,J,K,L,M,N> of(ControllerMethod14<A,B,C,D,E,F,G,H,I,J,K,L,M,N> functionalMethod) {
+        return functionalMethod;
+    }
+
+    static public <A,B,C,D,E,F,G,H,I,J,K,L,M,N,O> ControllerMethod15<A,B,C,D,E,F,G,H,I,J,K,L,M,N,O> of(ControllerMethod15<A,B,C,D,E,F,G,H,I,J,K,L,M,N,O> functionalMethod) {
+        return functionalMethod;
+    }
+
+}

ninja-core/src/main/java/ninja/FilterChain.java

@@ -20,11 +20,13 @@
  * A filter chain
  */
 public interface FilterChain {
+
     /**
      * Pass the request to the next filter
      * 
-     * @param context
-     *            The context for the request
+     * @param context The context for the request
+     * @return The result
      */
     Result next(Context context);
+
 }

ninja-core/src/main/java/ninja/FilterChainEnd.java

@@ -26,28 +26,20 @@
  * @author James Roper
  */
 class FilterChainEnd implements FilterChain {
-    private Provider<?> controllerProvider;
-    private ControllerMethodInvoker controllerMethodInvoker;
-    private Result result;
+
+    private final Provider<?> targetObjectProvider;
+    private final ControllerMethodInvoker controllerMethodInvoker;
 
-    FilterChainEnd(Result result) {
-        this.result = result;
-    }
-
-    FilterChainEnd(Provider<?> controllerProvider,
+    FilterChainEnd(Provider<?> targetObjectProvider,
                    ControllerMethodInvoker controllerMethodInvoker) {
-        this.controllerProvider = controllerProvider;
+        this.targetObjectProvider = targetObjectProvider;
         this.controllerMethodInvoker = controllerMethodInvoker;
     }
 
     @Override
     public Result next(Context context) {
-        if(result != null) {
-            return result;
-        }
-
-        Result controllerResult = (Result) controllerMethodInvoker.invoke(
-                controllerProvider.get(), context);
+        Result controllerResult = (Result)controllerMethodInvoker.invoke(
+            targetObjectProvider.get(), context);
 
         if (controllerResult instanceof AsyncResult) {
             // Make sure handle async has been called

ninja-core/src/main/java/ninja/FilterChainImpl.java

@@ -22,6 +22,7 @@
  * Implementation of the filter chain
  */
 class FilterChainImpl implements FilterChain {
+
     private final Provider<? extends Filter> filterProvider;
     private final FilterChain next;
 

ninja-core/src/main/java/ninja/Route.java

@@ -45,7 +45,6 @@ public class Route {
     //private static final String PATTERN_FOR_VARIABLE_PARTS_OF_ROUTE = "\\{.*?:\\s(.*?)\\}";
     private final String httpMethod;
     private final String uri;
-    private final Class controllerClass;
     private final Method controllerMethod;
     private final FilterChain filterChain;
 
@@ -54,15 +53,12 @@ public class Route {
 
     public Route(String httpMethod,
             String uri,
-            Class controllerClass,
             Method controllerMethod,
             FilterChain filterChain) {
         this.httpMethod = httpMethod;
         this.uri = uri;
-        this.controllerClass = controllerClass;
         this.controllerMethod = controllerMethod;
         this.filterChain = filterChain;
-
         parameterNames = ImmutableList.copyOf(doParseParameters(uri));
         regex = Pattern.compile(convertRawUriToRegex(uri));
     }
@@ -80,7 +76,7 @@ public String getUri() {
     }
 
     public Class<?> getControllerClass() {
-        return controllerClass;
+        return controllerMethod != null ? controllerMethod.getDeclaringClass() : null;
     }
 
     public FilterChain getFilterChain() {

ninja-core/src/main/java/ninja/RouteBuilder.java

@@ -16,16 +16,49 @@
 
 package ninja;
 
+import ninja.ControllerMethods.*;
 import ninja.utils.MethodReference;
 
 public interface RouteBuilder {
 
     RouteBuilder route(String uri);
 
-    void with(Class controller, String controllerMethod);
+    void with(Class<?> controllerClass, String controllerMethod);
 
+    @Deprecated
     void with(MethodReference controllerMethodRef);
 
+    /**
+     * A static result to return for this route.
+     * @param result The result to return on every request.
+     * @deprecated Use the functional interface methods to supply a new result
+     *      for each route request.  Its recommended to use <code>() -> Results.redirect("/")</code>.
+     */
+    @Deprecated
     void with(Result result);
 
+    void with(ControllerMethod functionalMethod);
+
+    void with(ControllerMethod0 functionalMethod);
+
+    <A> void with(ControllerMethod1<A> functionalMethod);
+
+    <A,B> void with(ControllerMethod2<A,B> functionalMethod);
+
+    <A,B,C> void with(ControllerMethod3<A,B,C> functionalMethod);
+
+    <A,B,C,D> void with(ControllerMethod4<A,B,C,D> functionalMethod);
+
+    <A,B,C,D,E> void with(ControllerMethod5<A,B,C,D,E> functionalMethod);
+
+    <A,B,C,D,E,F> void with(ControllerMethod6<A,B,C,D,E,F> functionalMethod);
+
+    <A,B,C,D,E,F,G> void with(ControllerMethod7<A,B,C,D,E,F,G> functionalMethod);
+
+    <A,B,C,D,E,F,G,H> void with(ControllerMethod8<A,B,C,D,E,F,G,H> functionalMethod);
+
+    <A,B,C,D,E,F,G,H,I> void with(ControllerMethod9<A,B,C,D,E,F,G,H,I> functionalMethod);
+
+    <A,B,C,D,E,F,G,H,I,J> void with(ControllerMethod10<A,B,C,D,E,F,G,H,I,J> functionalMethod);
+
 }