defmodule Rexbug.Translator do
@moduledoc """
Utility module for translating Elixir syntax to the one expected by
`:redbug`.
You probably don't need to use it directly.
"""
@valid_guard_functions [
:is_atom,
:is_binary,
:is_bitstring,
:is_boolean,
:is_float,
:is_function,
:is_integer,
:is_list,
:is_map,
:is_nil,
:is_number,
:is_pid,
:is_port,
:is_reference,
:is_tuple,
:abs,
:bit_size,
:byte_size,
:hd,
:length,
:map_size,
:round,
:tl,
:trunc,
:tuple_size,
# erlang guard
:size
]
@infix_guards_mapping %{
# comparison
:== => :==,
:!= => :"/=",
:=== => :"=:=",
:!== => :"=/=",
:> => :>,
:>= => :>=,
:< => :<,
:<= => :"=<"
}
@valid_infix_guards Map.keys(@infix_guards_mapping)
@infix_guard_combinators_mapping %{
:and => :andalso,
:or => :orelse
}
@valid_infix_guard_combinators Map.keys(@infix_guard_combinators_mapping)
# ===========================================================================
# Public functions
# ===========================================================================
# ---------------------------------------------------------------------------
# Translating trace pattern
# ---------------------------------------------------------------------------
@spec translate(Rexbug.trace_pattern()) ::
{:ok, charlist | atom} | {:ok, [charlist | atom]} | {:error, term}
@doc """
Translates the Elixir trace pattern(s) (understood by Rexbug) to the
Erlang trace pattern charlist(s) understood by `:redbug`.
The translated version is not necessarily the cleanest possible, but should
be correct and functionally equivalent.
## Example
iex> import Rexbug.Translator
iex> translate(":cowboy.start_clear/3")
{:ok, '\\'cowboy\\':\\'start_clear\\'/3'}
iex> translate("MyModule.do_sth(_, [pretty: true])")
{:ok, '\\'Elixir.MyModule\\':\\'do_sth\\'(_, [{\\'pretty\\', true}])'}
"""
def translate(s) when s in [:send, "send"], do: {:ok, :send}
def translate(r) when r in [:receive, "receive"], do: {:ok, :receive}
def translate(patterns) when is_list(patterns) do
patterns
|> Enum.map(&translate/1)
|> collapse_errors()
end
def translate(trace_pattern) when is_binary(trace_pattern) do
with {mfag, actions} = split_to_mfag_and_actions!(trace_pattern),
{:ok, quoted} <- Code.string_to_quoted(mfag),
{:ok, {mfa, guards}} = split_quoted_into_mfa_and_guards(quoted),
{:ok, {mfa, arity}} = split_mfa_into_mfa_and_arity(mfa),
{:ok, {module, function, args}} = split_mfa_into_module_function_and_args(mfa),
:ok <- validate_mfaa(module, function, args, arity),
{:ok, translated_module} <- translate_module(module),
{:ok, translated_function} <- translate_function(function),
{:ok, translated_args} <- translate_args(args),
{:ok, translated_arity} <- translate_arity(arity),
{:ok, translated_guards} <- translate_guards(guards),
translated_actions = translate_actions!(actions) do
translated =
case translated_arity do
:any ->
# no args, no arity
"#{translated_module}#{translated_function}#{translated_actions}"
arity when is_integer(arity) ->
# no args, arity present
"#{translated_module}#{translated_function}/#{arity}#{translated_actions}"
nil ->
# args present, no arity
"#{translated_module}#{translated_function}#{translated_args}#{translated_guards}#{
translated_actions
}"
end
{:ok, String.to_charlist(translated)}
end
end
def translate(_), do: {:error, :invalid_trace_pattern_type}
@doc false
def split_to_mfag_and_actions!(trace_pattern) do
{mfag, actions} =
case String.split(trace_pattern, " ::", parts: 2) do
[mfag, actions] -> {mfag, actions}
[mfag] -> {mfag, ""}
end
{String.trim(mfag), String.trim(actions)}
end
@spec translate_guards(term) :: {:ok, String.t()} | {:error, term}
defp translate_guards(nil), do: {:ok, ""}
defp translate_guards(els) do
_translate_guards(els)
|> map_success(fn guards -> " when #{guards}" end)
end
# ---------------------------------------------------------------------------
# Translating options
# ---------------------------------------------------------------------------
@spec translate_options(Keyword.t()) :: {:ok, Keyword.t()} | {:error, term}
@doc """
Translates the options to be passed to `Rexbug.start/2` to the format expected by
`:redbug`
Relevant values passed as strings will be converted to charlists.
"""
def translate_options(options) when is_list(options) do
options
|> Enum.map(&translate_option/1)
|> collapse_errors()
end
def translate_options(_), do: {:error, :invalid_options}
# ===========================================================================
# Private functions
# ===========================================================================
@binary_to_charlist_options [:file, :print_file]
defp translate_option({file_option, filename})
when file_option in @binary_to_charlist_options and is_binary(filename) do
{:ok, {file_option, String.to_charlist(filename)}}
end
defp translate_option({k, v}) do
{:ok, {k, v}}
end
defp translate_option(_), do: {:error, :invalid_options}
@spec collapse_errors([{:ok, term} | {:error, term}]) :: {:ok, [term]} | {:error, term}
defp collapse_errors(tuples) do
# we could probably play around with some monads for this
first_error = Enum.find(tuples, :no_error_to_collapse, fn res -> !match?({:ok, _}, res) end)
case first_error do
:no_error_to_collapse ->
results = Enum.map(tuples, fn {:ok, res} -> res end)
{:ok, results}
err ->
err
end
end
defp split_quoted_into_mfa_and_guards({:when, _line, [mfa, guards]}) do
{:ok, {mfa, guards}}
end
defp split_quoted_into_mfa_and_guards(els) do
{:ok, {els, nil}}
end
defp split_mfa_into_mfa_and_arity({:/, _line, [mfa, arity]}) do
{:ok, {mfa, arity}}
end
defp split_mfa_into_mfa_and_arity(els) do
{:ok, {els, nil}}
end
defp split_mfa_into_module_function_and_args({{:., _l1, [module, function]}, _l2, args}) do
{:ok, {module, function, args}}
end
defp split_mfa_into_module_function_and_args(els) do
{:ok, {els, nil, nil}}
end
# handling fringe cases that shouldn't happen
defp validate_mfaa(module, function, args, arity)
defp validate_mfaa(nil, _, _, _), do: {:error, :missing_module}
defp validate_mfaa(_, nil, args, _) when not (args in [nil, []]),
do: {:error, :missing_function}
defp validate_mfaa(_, nil, _, arity) when arity != nil, do: {:error, :missing_function}
defp validate_mfaa(_, _, args, arity)
when not (args in [nil, []]) and arity != nil do
{:error, :both_args_and_arity_provided}
end
defp validate_mfaa(_, _, _, _), do: :ok
defp translate_module({:__aliases__, _line, elixir_module}) when is_list(elixir_module) do
joined =
[:"Elixir" | elixir_module]
|> Enum.map(&Atom.to_string/1)
|> Enum.join(".")
{:ok, "'#{joined}'"}
end
defp translate_module(erlang_mod) when is_atom(erlang_mod) do
{:ok, "\'#{Atom.to_string(erlang_mod)}\'"}
end
defp translate_module(module), do: {:error, {:invalid_module, module}}
defp translate_function(nil) do
{:ok, ""}
end
defp translate_function(f) when is_atom(f) do
{:ok, ":'#{Atom.to_string(f)}'"}
end
defp translate_function(els) do
{:error, {:invalid_function, els}}
end
defp translate_args(nil), do: {:ok, ""}
defp translate_args(args) when is_list(args) do
args
|> Enum.map(&translate_arg/1)
|> collapse_errors()
|> map_success(&Enum.join(&1, ", "))
|> map_success(fn res -> "(#{res})" end)
end
defp translate_args(els) do
{:error, {:invalid_args, els}}
end
defp translate_arg(nil), do: {:ok, "nil"}
defp translate_arg(boolean) when is_boolean(boolean) do
{:ok, "#{boolean}"}
end
defp translate_arg(arg) when is_atom(arg) do
{:ok, "'#{Atom.to_string(arg)}'"}
end
defp translate_arg(string) when is_binary(string) do
# TODO: more strict ASCII checking here
if String.printable?(string) && byte_size(string) == String.length(string) do
{:ok, "<<\"#{string}\">>"}
else
translate_arg({:<<>>, [line: 1], [string]})
end
end
defp translate_arg({:<<>>, _line, contents}) when is_list(contents) do
contents
|> Enum.map(&translate_binary_element/1)
|> collapse_errors()
|> map_success(&Enum.join(&1, ", "))
|> map_success(fn res -> "<<#{res}>>" end)
end
# defp translate_arg(bs) when is_bitstring(bs) do
# :error
# end
defp translate_arg(ls) when is_list(ls) do
ls
|> Enum.map(&translate_arg/1)
|> collapse_errors()
|> map_success(fn elements -> "[#{Enum.join(elements, ", ")}]" end)
end
defp translate_arg({:-, _line, [num]}) when is_integer(num) do
with {:ok, translated_num} = translate_arg(num),
do: {:ok, "-#{translated_num}"}
end
defp translate_arg(num) when is_integer(num) do
{:ok, "#{num}"}
end
defp translate_arg(f) when is_float(f) do
{:error, {:bad_type, :float}}
end
defp translate_arg({:%{}, _line, kvs}) when is_list(kvs) do
{ks, vs} = Enum.unzip(kvs)
if Enum.any?(ks, &is_variable/1) do
{:error, :variable_in_map_key}
else
key_args =
ks
|> Enum.map(&translate_arg/1)
|> collapse_errors()
value_args =
vs
|> Enum.map(&translate_arg/1)
|> collapse_errors()
[key_args, value_args]
|> collapse_errors
|> map_success(fn [keys, values] ->
middle =
keys
|> Enum.zip(values)
|> Enum.map(fn {k, v} -> "#{k} => #{v}" end)
|> Enum.join(", ")
"\#{#{middle}}"
end)
end
end
# there's a catch here:
# iex(12)> Code.string_to_quoted!("{1,2,3}")
# {:{}, [line: 1], [1, 2, 3]}
# iex(13)> Code.string_to_quoted!("{1,2}")
# {1, 2}
defp translate_arg({:{}, _line, tuple_elements}) do
tuple_elements
|> Enum.map(&translate_arg/1)
|> collapse_errors()
|> map_success(fn elements -> "{#{Enum.join(elements, ", ")}}" end)
end
# the literally represented 2-tuples
defp translate_arg({x, y}), do: translate_arg({:{}, [line: 1], [x, y]})
# other atoms are just variable names
defp translate_arg({var, _line, nil}) when is_atom(var) do
var
|> Atom.to_string()
|> String.capitalize()
|> wrap_in_ok()
end
defp translate_arg(arg) do
{:error, {:invalid_arg, arg}}
end
defp is_variable({var, _line, nil}) when is_atom(var), do: true
defp is_variable(_), do: false
defp translate_binary_element(i) when is_integer(i) do
{:ok, "#{i}"}
end
defp translate_binary_element(s) when is_binary(s) do
res =
s
|> :binary.bin_to_list()
|> Enum.join(", ")
{:ok, res}
end
defp translate_binary_element(els), do: {:error, {:invalid_binary_element, els}}
defp translate_arity({var, [line: 1], nil}) when is_atom(var) do
{:ok, :any}
end
defp translate_arity(i) when is_integer(i) do
{:ok, i}
end
defp translate_arity(none) when none in [nil, ""] do
{:ok, nil}
end
defp translate_arity(els) do
{:error, {:invalid_arity, els}}
end
defp translate_actions!(empty) when empty in [nil, ""] do
""
end
defp translate_actions!(actions) when is_binary(actions) do
" -> #{actions}"
end
# ---------------------------------------------------------------------------
# Guards
# ---------------------------------------------------------------------------
@spec _translate_guards(term) :: {:ok, String.t()} | {:error, term}
defp _translate_guards({:not, _line, [arg]}) do
_translate_guards(arg)
|> map_success(fn guard -> "not #{guard}" end)
end
defp _translate_guards({combinator, _line, [a, b]})
when combinator in @valid_infix_guard_combinators do
erlang_combinator =
@infix_guard_combinators_mapping[combinator]
|> Atom.to_string()
with {:ok, a_guards} <- _translate_guards(a),
{:ok, b_guards} <- _translate_guards(b),
do: {:ok, "(#{a_guards} #{erlang_combinator} #{b_guards})"}
end
defp _translate_guards(els), do: translate_guard(els)
@spec translate_guard(term) :: {:ok, String.t()} | {:error, term}
defp translate_guard({guard_fun, _line, args})
when guard_fun in @valid_guard_functions do
with translated_fun = Atom.to_string(guard_fun),
{:ok, translated_args} <- translate_args(args),
do: {:ok, "#{translated_fun}#{translated_args}"}
end
defp translate_guard({infix_guard_fun, _line, [a, b]})
when infix_guard_fun in @valid_infix_guards do
translated_infix_function =
@infix_guards_mapping[infix_guard_fun]
|> Atom.to_string()
with {:ok, a_guard} <- translate_guard(a),
{:ok, b_guard} <- translate_guard(b),
do: {:ok, "#{a_guard} #{translated_infix_function} #{b_guard}"}
end
defp translate_guard(els) do
translate_arg(els)
end
# ---------------------------------------------------------------------------
# Helper functions
# ---------------------------------------------------------------------------
defp map_success({:ok, var}, fun) do
{:ok, fun.(var)}
end
defp map_success(els, _), do: els
defp wrap_in_ok(x), do: {:ok, x}
end
