Add route_info lookup

lib/phoenix/router.ex

@@ -266,7 +266,7 @@ defmodule Phoenix.Router do
   def __call__(%{private: %{phoenix_bypass: :all}} = conn, _match) do
     conn
   end
-  def __call__(conn, {path_params, prepare, pipeline, {plug, opts}}) do
+  def __call__(conn, {_route, path_params, prepare, pipeline, {plug, opts}}) do
     case conn |> prepare.(path_params) |> pipeline.() do
       %Plug.Conn{halted: true} = halted_conn ->
         halted_conn
@@ -389,7 +389,8 @@ defmodule Phoenix.Router do
 
         @doc false
         def __match_route__(unquote(verb_match), unquote(path), unquote(host)) do
-          {unquote(path_params),
+          {unquote(Macro.escape(route)),
+           unquote(path_params),
            fn var!(conn, :conn), var!(path_params, :conn) -> unquote(prepare) end,
            &unquote(Macro.var(pipe_name, __MODULE__))/1,
            unquote(dispatch)}
@@ -811,4 +812,36 @@ defmodule Phoenix.Router do
       unquote(add_route(:forward, :*, path, plug, plug_opts, router_opts))
     end
   end
+
+  @doc """
+  Returns the compile-time route info and runtime path params for a request.
+
+  A tuple is returned containing matching `%Phoenix.Router.Route{}` struct and
+  the path params that matched the request path.
+
+  ## Examples
+
+      iex> Phoenix.Router.route_info(MyRouter, "GET", "/posts/123", "myhost")
+      {%Phoenix.Router.Route{
+         assigns: %{},
+         helper: "post",
+         host: nil,
+         kind: :match,
+         opts: :show,
+         path: "/posts/:id",
+         pipe_through: [:browser],
+         plug: MyAppWeb.PostController,
+         verb: :get
+      }, %{"id" => "123"}}
+
+      iex> Phoenix.Router.route_info(MyRouter, "GET", "/not-exists", "myhost")
+      :error
+  """
+  def route_info(router, method, path, host) do
+    split_path = for segment <- String.split(path, "/"), segment != "", do: segment
+    case router.__match_route__(method, split_path, host) do
+      {%Route{} = route, path_params, _prepare, _pipes, _dispatch} -> {route, path_params}
+      :error -> :error
+    end
+  end
 end

lib/phoenix/test/conn_test.ex

@@ -580,7 +580,7 @@ defmodule Phoenix.ConnTest do
     case router.__match_route__("GET", path_info, host || conn.host) do
       :error ->
         raise Phoenix.Router.NoRouteError, conn: conn, router: router
-      {path_params, _prepare, _pipes, _dispatch} ->
+      {_route, path_params, _prepare, _pipes, _dispatch} ->
         Enum.into(path_params, %{}, fn {key, val} -> {String.to_atom(key), val} end)
     end
   end

test/phoenix/router/routing_test.exs

@@ -29,7 +29,7 @@ defmodule Phoenix.Router.RoutingTest do
     get "/backups/*path", UserController, :image
     get "/static/images/icons/*image", UserController, :image
 
-    trace "/trace", UserController, :trace
+    trace("/trace", UserController, :trace)
     options "/options", UserController, :options
     connect "/connect", UserController, :connect
     match :move, "/move", UserController, :move
@@ -165,4 +165,52 @@ defmodule Phoenix.Router.RoutingTest do
     assert conn.status == 200
     assert conn.resp_body == "users any"
   end
+
+  test "route_info returns route string and path params" do
+    assert {%Phoenix.Router.Route{
+              assigns: %{},
+              helper: "user",
+              host: nil,
+              kind: :match,
+              line: 39,
+              opts: :not_found,
+              path: "/*path",
+              pipe_through: [],
+              plug: Phoenix.Router.RoutingTest.UserController,
+              private: %{},
+              verb: :get
+            },
+            %{"path" => ["foo", "bar", "baz"]}} =
+             Phoenix.Router.route_info(Router, "GET", "foo/bar/baz", nil)
+
+    assert {%Phoenix.Router.Route{
+              assigns: %{},
+              helper: "users",
+              host: nil,
+              kind: :match,
+              line: 24,
+              opts: :show,
+              path: "/users/:id",
+              pipe_through: [],
+              plug: Phoenix.Router.RoutingTest.UserController,
+              private: %{},
+              verb: :get
+            }, %{"id" => "1"}} = Phoenix.Router.route_info(Router, "GET", "users/1", nil)
+
+    assert {%Phoenix.Router.Route{
+              assigns: %{},
+              helper: "users",
+              host: nil,
+              kind: :match,
+              line: 22,
+              opts: :index,
+              path: "/",
+              pipe_through: [],
+              plug: Phoenix.Router.RoutingTest.UserController,
+              private: %{},
+              verb: :get
+            }, %{}} = Phoenix.Router.route_info(Router, "GET", "/", "host")
+
+    assert Phoenix.Router.route_info(Router, "POST", "/not-exists", "host") == :error
+  end
 end