github_issues

# Based on the book "Programming Elixir" by Dave Thomas.


defmodule GitHub.Issues.CLI do
  @moduledoc """

  Handles the command line parsing and the dispatch to

  the various functions that end up generating a table

  of the first or last `n` issues of a GitHub project.

  """

  alias GitHub.Issues
  alias IO.ANSI.Table.Formatter
  alias IO.ANSI.Table.Style

  @type parsed :: {String.t, String.t, integer, boolean, atom} | :help

  @app      Mix.Project.config[:app]
  @aliases  Application.get_env(@app, :aliases)
  @count    Application.get_env(@app, :default_count)
  @escript  Mix.Local.name_for(:escript, Mix.Project.config)
  @strict   Application.get_env(@app, :strict)
  @switches Application.get_env(@app, :default_switches)

  @doc """

  Parses and processes the command line arguments.



  ## Parameters



    - `argv` - command line arguments (list)

  """
  @spec main([String.t]) :: :ok | no_return
  def main(argv) do
    with {user, project, count, bell, style} <- parse(argv),
        {:ok, issues} <- Issues.fetch(user, project) do
      Formatter.print_table(issues, count, bell, style)
    else
      :help -> help()
      {:error, reason} -> report_error(reason)
    end
  end

  @spec report_error(any) :: no_return
  defp report_error(reason) when is_binary(reason) do
    IO.puts "Error fetching from GitHub: #{reason}"
    System.halt(2)
  end
  defp report_error(reason) do
    IO.puts "Error fetching from GitHub: #{inspect reason}"
    System.halt(2)
  end

  @spec help :: no_return
  defp help do
    # Examples of usage on Windows:

    #   escript github_issues --help

    #   escript github_issues elixir-lang elixir 7 --last

    #   escript github_issues myfreeweb httpotion --bell

    #   escript github_issues dynamo dynamo -lb 8 -t GREEN

    #   escript github_issues dynamo dynamo -bl 9 --table-style=dark

    #   escript github_issues dynamo dynamo 11 -blt light

    # Examples of usage on Mac:

    #   ./github_issues laravel elixir

    prefix = case :os.type do
      {:win32, _} -> "usage: escript #{@escript}"
      ___________ -> "usage: ./#{@escript}"
    end
    filler = String.duplicate " ", String.length(prefix)
    line_1 = "[(-h | --help)] <github-user> <github-project>"
    line_2 = "[(-l | --last)] <count> [(-b | --bell)]"
    line_3 = "[(-t | --table-style)=<table-style>]"
    IO.write """

      #{prefix} #{line_1}

      #{filler} #{line_2}

      #{filler} #{line_3}

      where:

        - default <count> is #{@count}

        - default <table-style> is #{@switches[:table_style]}

        - <table-style> is one of:

      """
    Style.texts "    • &tag&filler - &note", &IO.puts/1
    System.halt(0)
  end

  @doc """

  Parses the command line arguments.



  `argv` can be `-h` or `--help`, which returns `:help`. Otherwise

  it is a GitHub user name, project name, and optionally the number

  of issues to format (from the first one). To format the last `n`

  issues, specify switch `--last` which will return a negative count.



  Returns either a tuple of `{user, project, count, bell, style}`

  or `:help` if `--help` was given.



  ## Parameters



    - `argv` - command line arguments (list)



  ## Switches



    - `-h` or `--help`        - for help

    - `-l` or `--last`        - to format the last `n` issues

    - `-b` or `--bell`        - to ring the bell

    - `-t` or `--table-style` - to apply a specific table style



  ## Table styles



  #{Style.texts "  - &tag&filler - &note\n"}

  ## Examples



      iex> alias GitHub.Issues.CLI

      iex> CLI.parse(["-h"])

      :help



      iex> alias GitHub.Issues.CLI

      iex> CLI.parse(["user", "project", "99"])

      {"user", "project", 99, false, :medium}



      iex> alias GitHub.Issues.CLI

      iex> CLI.parse(["user", "project", "88", "--last"])

      {"user", "project", -88, false, :medium}



      iex> alias GitHub.Issues.CLI

      iex> CLI.parse(["user", "project", "6", "--table-style", "dark"])

      {"user", "project", 6, false, :dark}

  """
  @spec parse([String.t]) :: parsed
  def parse(argv) do
    argv
    |> OptionParser.parse(strict: @strict, aliases: @aliases)
    |> reformat
  end

  @spec reformat({Keyword.t, [String.t], [tuple]}) :: parsed
  defp reformat({switches, args, []}) do
    with {user, project, count} <- normalize(args),
        %{
          help: false, last: last, bell: bell, table_style: table_style
        } <- Map.merge(Map.new(@switches), Map.new(switches)),
        {:ok, style} <- Style.style_for(table_style) do
      {user, project, last && -count || count, bell, style}
    else
      _ -> :help
    end
  end
  defp reformat(_), do: :help

  @spec normalize([String.t]) :: {String.t, String.t, non_neg_integer} | :error
  defp normalize([user, project, count]) do
    with {int, ""} when int >= 0 <- Integer.parse(count) do
      {user, project, int}
    else
      _ -> :error
    end
  end
  defp normalize([user, project]), do: {user, project, @count}
  defp normalize(_), do: :error
end