defmodule ESpec.Formatters.Doc do
@moduledoc """
Generates plain colored text output.
"""
@green IO.ANSI.green()
@red IO.ANSI.red()
@cyan IO.ANSI.cyan()
@yellow IO.ANSI.yellow()
# @grey IO.ANSI.light_black()
@reset IO.ANSI.reset()
@main_colors [stacktrace: @cyan, diff_headers: @cyan]
@status_colors [success: @green, failure: @red, pending: @yellow]
@status_symbols [success: ".", failure: "F", pending: "*"]
@diff_colors [
diff_delete: :red,
diff_delete_whitespace: IO.ANSI.color_background(2, 0, 0),
diff_insert: :green,
diff_insert_whitespace: IO.ANSI.color_background(0, 2, 0)
]
alias ESpec.Example
use ESpec.Formatters.Base
@doc "Formats an example result."
def format_example(example, opts) do
color = color_for_status(example.status)
symbol = symbol_for_status(example.status)
if opts[:details] do
trace_description(example)
else
colorize(color, symbol)
end
end
@doc "Formats the final result."
def format_result(examples, durations, opts) do
pending = Example.pendings(examples)
string = ""
string = if Enum.any?(pending), do: string <> format_pending(pending), else: string
failed = Example.failure(examples)
string = if Enum.any?(failed), do: string <> format_failed(failed, opts), else: string
string = string <> format_footer(examples, failed, pending)
string = string <> format_times(durations, failed, pending)
string <> format_seed()
end
defp format_failed(failed, opts) do
failed
|> Enum.with_index()
|> Enum.map_join("\n", fn {example, index} ->
do_format_failed_example(example, index, opts)
end)
end
defp format_pending(pending) do
pending
|> Enum.with_index()
|> Enum.map_join("\n", fn {example, index} ->
do_format_pending_example(example, example.result, index)
end)
end
defp do_format_pending_example(example, info, index) do
color = color_for_status(example.status)
description = one_line_description(example)
file_line_ref = "#{example.file}:#{example.line}"
[
"\n",
"\t#{index + 1}) #{description}",
"\t#{colorize(@main_colors[:stacktrace], file_line_ref)}",
"\t#{colorize(color, info)}"
]
|> Enum.join("\n")
end
defp do_format_failed_example(example, index, opts) do
color = color_for_status(example.status)
description = one_line_description(example)
error_message =
example.error.message
|> String.replace("\n", "\n\t ")
stacktrace = do_format_stacktrace(example)
Enum.join(
[
"\n",
"\t#{index + 1}) #{description}",
"\t#{colorize(@main_colors[:stacktrace], stacktrace)}",
"\t#{colorize(color, error_message)}"
],
"\n"
) <> if Map.get(opts, :diff_enabled?, true), do: do_format_diff(example.error), else: ""
end
defp do_format_stacktrace(example) do
list =
example
|> do_format_stacktrace_list()
|> Enum.reverse()
line = "#{Path.relative_to_cwd(example.file)}:#{example.line}"
if Enum.empty?(list) do
line
else
["#{line}: (example)" | list]
|> Enum.reverse()
|> Enum.join("\n\t")
end
end
defp do_format_stacktrace_list(example) do
if is_nil(example.error.stacktrace) do
[]
else
example.error.stacktrace
|> remove_example_if_first(example)
|> Enum.map(fn {module, function, arity, [file: file, line: line]} = item ->
if in_this_example?(example, item) do
"#{file}:#{line}: (inside example)"
else
"#{file}:#{line}: #{module}.#{function}/#{arity}"
end
end)
end
end
defp in_this_example?(example, {module, function, arity, [file: file, line: _line]}) do
module == example.module && function == example.function && arity == 1 &&
file == String.to_charlist(Path.relative_to_cwd(example.file))
end
defp remove_example_if_first([], _example) do
[]
end
defp remove_example_if_first([{_, _, _, [file: _, line: line]} = first | rest] = trace, example) do
if in_this_example?(example, first) && line == example.line do
rest
else
trace
end
end
defp do_format_diff(%ESpec.AssertionError{extra: %{diff_fn: f}}) when is_function(f, 0) do
format_diff(f.())
end
defp do_format_diff(_), do: ""
defp colorize(ansi_color_code, string) do
[ansi_color_code, string, @reset]
|> IO.ANSI.format_fragment(true)
|> IO.iodata_to_binary()
end
defp format_diff(nil) do
""
end
if Version.match?(System.version(), ">= 1.10.0") do
defp format_diff(%ExUnit.Diff{
left: left,
right: right
}) do
left =
left
|> ExUnit.Diff.to_algebra(fn doc ->
Inspect.Algebra.color(
doc,
get_color_by_content(doc, :diff_delete, :diff_delete_whitespace),
%Inspect.Opts{syntax_colors: @diff_colors}
)
end)
|> Inspect.Algebra.nest(20)
|> Inspect.Algebra.format(80)
right =
right
|> ExUnit.Diff.to_algebra(fn doc ->
Inspect.Algebra.color(
doc,
get_color_by_content(doc, :diff_insert, :diff_insert_whitespace),
%Inspect.Opts{syntax_colors: @diff_colors}
)
end)
|> Inspect.Algebra.nest(20)
|> Inspect.Algebra.format(80)
"\n\t #{colorize(@main_colors[:diff_headers], "expected:")} " <>
IO.iodata_to_binary(left) <>
"\n\t #{colorize(@main_colors[:diff_headers], "actual:")} " <>
IO.iodata_to_binary(right)
end
defp get_color_by_content(content, color_if_normal, color_if_whitespace)
when is_binary(content) do
if String.trim_leading(content) == "", do: color_if_whitespace, else: color_if_normal
end
defp get_color_by_content(_content, color_if_normal, _color_if_whitespace) do
color_if_normal
end
else
defp format_diff({l, r}) do
[
"",
"\t #{colorize(@main_colors[:diff_headers], "expected:")} #{colorize_diff(r)}",
"\t #{colorize(@main_colors[:diff_headers], "actual:")} #{colorize_diff(l)}"
]
|> Enum.join("\n")
end
defp colorize_diff([{:eq, text} | rest]) do
text <> colorize_diff(rest)
end
defp colorize_diff([{:ins, text} | rest]) do
colorize(@diff_colors[:diff_insert], text) <> colorize_diff(rest)
end
defp colorize_diff([{:del, text} | rest]) do
colorize(@diff_colors[:diff_delete], text) <> colorize_diff(rest)
end
defp colorize_diff([{:ins_whitespace, length} | rest]) do
colorize(@diff_colors[:diff_insert_whitespace], String.duplicate(" ", length)) <>
colorize_diff(rest)
end
defp colorize_diff([]) do
""
end
end
defp format_footer(examples, failed, pending) do
color = get_color_for_content(failed, pending)
parts = ["#{Enum.count(examples)} examples", "#{Enum.count(failed)} failures"]
parts = if Enum.any?(pending), do: parts ++ ["#{Enum.count(pending)} pending"], else: parts
parts_string = Enum.join(parts, ", ")
"\n\n\t#{colorize(color, parts_string)}"
end
defp format_times({start_loading_time, finish_loading_time, finish_specs_time}, failed, pending) do
color = get_color_for_content(failed, pending)
load_time = :timer.now_diff(finish_loading_time, start_loading_time)
spec_time = :timer.now_diff(finish_specs_time, finish_loading_time)
finished_in =
"Finished in #{us_to_sec(load_time + spec_time)} seconds" <>
" (#{us_to_sec(load_time)}s on load, #{us_to_sec(spec_time)}s on specs)"
"\n\n\t#{colorize(color, finished_in)}\n\n"
end
defp format_seed do
if ESpec.Configuration.get(:order) do
""
else
seed = ESpec.Configuration.get(:seed)
"\tRandomized with seed #{seed}\n\n"
end
end
defp us_to_sec(us), do: div(us, 10_000) / 100
defp get_color_for_content(failed, pending) do
if Enum.any?(failed) do
@status_colors[:failure]
else
if Enum.any?(pending), do: @status_colors[:pending], else: @status_colors[:success]
end
end
defp one_line_description(example) do
desc = Example.context_descriptions(example) ++ [example.description]
desc
|> Enum.join(" ")
|> String.trim_trailing()
end
defp trace_description(example) do
color = color_for_status(example.status)
ex_desc =
if String.length(example.description) > 0 do
"#{colorize(color, example.description)}"
else
status_message(example, color)
end
array = Example.context_descriptions(example) ++ [ex_desc]
{result, _} =
Enum.reduce(array, {"", ""}, fn description, acc ->
{d, w} = acc
{d <> w <> "#{description}" <> "\n", w <> " "}
end)
result
end
defp status_message(example, color) do
if example.status == :failure do
"#{colorize(color, example.error.message)}"
else
"#{colorize(color, inspect(example.result))}"
end
end
defp color_for_status(status), do: Keyword.get(@status_colors, status)
defp symbol_for_status(status), do: Keyword.get(@status_symbols, status)
end
