defmodule DoIt.Output do
@moduledoc """
This module formats command help outputs.
"""
alias DoIt.{Argument, Option}
@doc """
It gets the length of the longer name attribute.
## Examples
iex> DoIt.Output.longer_name([%{name: "great"}, %{name: "greatest"}])
8
iex> DoIt.Output.longer_name([%{name: "Elixir"}, %{name: "Erlang"}, %{name: "DoIt"}, %{name: "OTP"}])
6
"""
def longer_name(list) do
list
|> Enum.map(fn %{name: name} -> "#{name}" end)
|> Enum.max_by(&String.length/1)
|> String.length()
end
@doc """
It formats the given `DoIt.Argument` name attribute with spaces on the right, accordingly with the `align` parameter.
## Examples
iex> DoIt.Output.format_argument_name(%DoIt.Argument{name: :verbose, type: :boolean, description: "Makes the command verbose"}, 15)
"verbose "
"""
def format_argument_name(%Argument{name: name}, align),
do: "#{String.pad_trailing(Atom.to_string(name), align)}"
@doc """
It returns the description from `DoIt.Argument`.
## Example
iex> DoIt.Output.format_argument_description(%DoIt.Argument{name: :verbose, type: :boolean, description: "Makes the command verbose"})
"Makes the command verbose"
"""
def format_argument_description(%Argument{description: description}), do: description
@doc """
It returns the allowed values from the given `DoIt.Argument`.
## Examples
iex> DoIt.Output.format_argument_allowed_values(%DoIt.Argument{name: :op, type: :string, description: "Operation", allowed_values: ["+", "-", "*", "/"]})
" (Allowed Values: \\"+\\", \\"-\\", \\"*\\", \\"/\\")"
iex> DoIt.Output.format_argument_allowed_values(%DoIt.Argument{name: :verbose, type: :boolean, description: "Makes the command verbose"})
""
iex> DoIt.Output.format_argument_allowed_values(%DoIt.Argument{name: :number, type: :integer, description: "Numerical digit", allowed_values: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]})
" (Allowed Values: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9)"
"""
def format_argument_allowed_values(%Argument{allowed_values: nil}), do: ""
def format_argument_allowed_values(%Argument{type: :string, allowed_values: allowed_values}),
do: " (Allowed Values: \"#{Enum.join(allowed_values, "\", \"")}\")"
def format_argument_allowed_values(%Argument{allowed_values: allowed_values}),
do: " (Allowed Values: #{Enum.join(allowed_values, ", ")})"
@doc """
It formats the given `DoIt.Option` alias attribute.
## Examples
iex> DoIt.Output.format_option_alias(%DoIt.Option{name: :help, type: :boolean, description: "Shows the help command", alias: nil})
" "
iex> DoIt.Output.format_option_alias(%DoIt.Option{name: :help, type: :boolean, description: "Shows the help command", alias: :h})
"-h,"
"""
def format_option_alias(%Option{alias: nil}), do: " "
def format_option_alias(%Option{alias: alias}), do: "-#{Atom.to_string(alias)},"
@doc """
It formats the given `DoIt.Option` name attribute with spaces on the right, accordingly with the `align` parameter.
## Examples
iex> DoIt.Output.format_option_name(%DoIt.Option{name: :help, type: :boolean, description: "Shows the help command", alias: nil}, 10)
"--help "
iex> DoIt.Output.format_option_name(%DoIt.Option{name: :log_level, type: :string, description: "Set the logging level", alias: nil}, 12)
"--log-level "
"""
def format_option_name(%Option{name: name}, align),
do: "--#{name |> Atom.to_string() |> String.replace("_", "-") |> String.pad_trailing(align)}"
@doc """
It returns the description from `DoIt.Option`.
## Examples
iex> DoIt.Output.format_option_description(%DoIt.Option{name: :help, type: :boolean, description: "Shows the help command", alias: nil})
"Shows the help command"
"""
def format_option_description(%Option{description: description}), do: description
@doc """
It formats the given `DoIt.Option` default attribute.
## Examples
iex> DoIt.Output.format_option_default(%DoIt.Option{name: :log_level, type: :string, description: "Set the logging level", alias: nil, default: "warn"})
" (Default: \\"warn\\")"
iex> DoIt.Output.format_option_default(%DoIt.Option{name: :skip_lines, type: :integer, description: "Lines to skip", alias: nil, default: 10})
" (Default: 10)"
iex> DoIt.Output.format_option_default(%DoIt.Option{name: :help, type: :boolean, description: "Shows the help command", alias: nil})
""
"""
def format_option_default(%Option{default: nil}), do: ""
def format_option_default(%Option{type: :string, default: default}),
do: " (Default: \"#{default}\")"
def format_option_default(%Option{default: default}), do: " (Default: #{default})"
def format_option_allowed_values(%Option{allowed_values: nil}), do: ""
@doc """
It returns the allowed values from the given `DoIt.Option`.
## Examples
iex> DoIt.Output.format_option_allowed_values(%DoIt.Option{name: :op, type: :string, description: "Operation", allowed_values: ["+", "-", "*", "/"]})
" (Allowed Values: \\"+\\", \\"-\\", \\"*\\", \\"/\\")"
iex> DoIt.Output.format_option_allowed_values(%DoIt.Option{name: :verbose, type: :boolean, description: "Makes the command verbose"})
""
iex> DoIt.Output.format_option_allowed_values(%DoIt.Option{name: :number, type: :integer, description: "Numerical digit", allowed_values: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]})
" (Allowed Values: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9)"
"""
def format_option_allowed_values(%Option{type: :string, allowed_values: allowed_values}),
do: " (Allowed Values: \"#{Enum.join(allowed_values, "\", \"")}\")"
def format_option_allowed_values(%Option{allowed_values: allowed_values}),
do: " (Allowed Values: #{Enum.join(allowed_values, ", ")})"
def print_help(
app: app,
commands: commands,
main_description: main_description
) do
IO.puts("")
IO.puts("Usage: #{app} COMMAND")
IO.puts("")
IO.puts(main_description)
IO.puts("")
IO.puts("Commands:")
align = longer_name(commands)
for %{name: name, description: description} <- commands do
IO.puts(" #{String.pad_trailing(name, align)} #{description}")
end
IO.puts("")
end
def print_help(
app: app,
command: command,
description: description,
arguments: arguments,
options: options
) do
IO.puts("")
IO.puts(
"Usage: #{app} #{command}" <>
"#{if Enum.empty?(options), do: " ", else: " [OPTIONS] "}" <>
"#{arguments |> Enum.reverse() |> Enum.map_join(" ", fn %{name: name} -> "<#{name}>" end)}"
)
IO.puts("")
IO.puts(description)
IO.puts("")
if !Enum.empty?(arguments) do
align = longer_name(arguments)
IO.puts("Arguments:")
for argument <- Enum.reverse(arguments) do
with name <- format_argument_name(argument, align),
description <- format_argument_description(argument),
allowed_values <- format_argument_allowed_values(argument) do
IO.puts(" #{name} #{description}#{allowed_values}")
end
end
IO.puts("")
end
if !Enum.empty?(options) do
align = longer_name(options)
IO.puts("Options:")
for option <- Enum.reverse(options) do
with alias <- format_option_alias(option),
name <- format_option_name(option, align),
description <- format_option_description(option),
default <- format_option_default(option),
allowed_values <- format_option_allowed_values(option) do
IO.puts(" #{alias} #{name} #{description}#{default}#{allowed_values}")
end
end
IO.puts("")
end
end
def print_errors(errors) when is_list(errors) do
IO.puts("error(s):\n#{errors |> Enum.map_join("\n", fn error -> " * #{error}" end)}")
end
def print_errors(error), do: IO.puts(error)
def print_invalid_options(command, invalid_options) do
IO.puts(
"invalid option(s) for command #{command}:\n#{invalid_options |> Enum.map_join("\n", fn
{option, nil} -> " * #{option} without value"
{option, value} -> " * #{option} with #{value}"
end)}"
)
end
end
