Current section

Files

Jump to
ash_json_api lib mix tasks ash_json_api.routes.ex
Raw

lib/mix/tasks/ash_json_api.routes.ex

# SPDX-FileCopyrightText: 2019 ash_json_api contributors <https://github.com/ash-project/ash_json_api/graphs/contributors>
#
# SPDX-License-Identifier: MIT
defmodule Mix.Tasks.AshJsonApi.Routes do
use Mix.Task
require Logger
alias AshJsonApi.Router.ConsoleFormatter
@moduledoc """
Prints all routes pertaining to AshJsonApi.Router for the default or a given router.
This task can be called directly, accepting the same options as `mix phx.routes`, except for `--info`.
Accepts option `--json_router` to specify your Ash Json Router. Defaults to `YourAppWeb.AshJsonApiRouter`.
Alternatively, you can modify your aliases task to run them back to back it.
```elixir
aliases: ["phx.routes": ["do", "phx.routes,", "ash_json_api.routes"]]
```
"""
@shortdoc "Prints all routes by AshJsonApiRouter"
@impl true
def run(args, base \\ Mix.Phoenix.base()) do
if Code.ensure_loaded?(Phoenix.Router) &&
function_exported?(Phoenix.Router, :__formatted_routes__, 1) do
raise """
AshJsonApi routes are now included in `mix phx.routes` automatically.
There is no need to use this task or include it in your aliases.
Remove: `ash_json_api.routes`
"""
end
Mix.Task.run("compile", args)
Mix.Task.reenable("ash_json_api.routes")
{opts, args, _} =
OptionParser.parse(args,
switches: [endpoint: :string, router: :string, json_router: :string]
)
{router_mod, json_router_mod, endpoint_mod} =
case args do
[passed_router] ->
{router(passed_router, base), json_router(opts[:json_router], base), opts[:endpoint]}
[] ->
{router(opts[:router], base), json_router(opts[:json_router], base),
endpoint(opts[:endpoint], base)}
end
case Keyword.fetch(opts, :info) do
{:ok, url} ->
get_url_info(url, {router_mod, opts})
:error ->
router_mod
|> ConsoleFormatter.format(json_router_mod, endpoint_mod)
|> Mix.shell().info()
end
end
defp router(nil, base) do
if Mix.Project.umbrella?() do
Mix.raise("""
umbrella applications require an explicit router to be given to phx.routes, for example:
$ mix ash_json_api.routes MyAppWeb.Router
An alias can be added to mix.exs aliases to automate this:
"ash_json_api.routes": "ash_json_api.routes MyAppWeb.Router"
""")
end
web_router = web_mod(base, "Router")
old_router = app_mod(base, "Router")
loaded(web_router) || loaded(old_router) ||
Mix.raise("""
no router found at #{inspect(web_router)} or #{inspect(old_router)}.
An explicit router module may be given to ash_json_api.routes, for example:
$ mix ash_json_api.routes MyAppWeb.Router
An alias can be added to mix.exs aliases to automate this:
"ash_json_api.routes": "ash_json_api.routes MyAppWeb.Router"
""")
end
defp router(router_name, _base) do
arg_router = Module.concat([router_name])
loaded(arg_router) || Mix.raise("the provided router, #{inspect(arg_router)}, does not exist")
end
defp json_router(nil, base) do
loaded(web_mod(base, "AshJsonApiRouter"))
end
defp json_router(module, _base) do
loaded(web_mod([module], "AshJsonApiRouter"))
end
defp endpoint(nil, base) do
loaded(web_mod(base, "Endpoint"))
end
defp endpoint(module, _base) do
loaded(Module.concat([module]))
end
defp app_mod(base, name), do: Module.concat([base, name])
defp web_mod(base, name), do: Module.concat(["#{base}Web", name])
defp loaded(module) do
if Code.ensure_loaded?(module), do: module
end
def get_url_info(url, {router_mod, _opts}) do
%{path: path} = URI.parse(url)
meta = Phoenix.Router.route_info(router_mod, "GET", path, "")
%{plug: plug, plug_opts: plug_opts} = meta
{module, func_name} =
if log_mod = meta[:log_module] do
{log_mod, meta[:log_function]}
else
{plug, plug_opts}
end
Mix.shell().info("Module: #{inspect(module)}")
if func_name, do: Mix.shell().info("Function: #{inspect(func_name)}")
file_path = get_file_path(module)
if line = get_line_number(module, func_name) do
Mix.shell().info("#{file_path}:#{line}")
else
Mix.shell().info("#{file_path}")
end
end
defp get_file_path(module_name) do
[compile_infos] = Keyword.get_values(module_name.module_info(), :compile)
[source] = Keyword.get_values(compile_infos, :source)
source
end
defp get_line_number(_, nil), do: nil
defp get_line_number(module, function_name) do
{_, _, _, _, _, _, functions_list} = Code.fetch_docs(module)
function_infos =
functions_list
|> Enum.find(fn {{type, name, _}, _, _, _, _} ->
type == :function and name == function_name
end)
case function_infos do
{_, line, _, _, _} -> line
nil -> nil
end
end
end