Initial commit

Author: fuelen

.formatter.exs

@@ -0,0 +1,4 @@
+# Used by "mix format"
+[
+  inputs: ["{mix,.formatter}.exs", "{config,lib,test}/**/*.{ex,exs}"]
+]

.gitignore

@@ -0,0 +1,26 @@
+# The directory Mix will write compiled artifacts to.
+/_build/
+
+# If you run "mix test --cover", coverage assets end up here.
+/cover/
+
+# The directory Mix downloads your dependencies sources to.
+/deps/
+
+# Where third-party dependencies like ExDoc output generated docs.
+/doc/
+
+# Ignore .fetch files in case you like to edit your project deps locally.
+/.fetch
+
+# If the VM crashes, it generates a dump, let's ignore it too.
+erl_crash.dump
+
+# Also ignore archive artifacts (built via "mix archive.build").
+*.ez
+
+# Ignore package tarball (built via "mix hex.build").
+owl-*.tar
+
+# Temporary files, for example, from tests.
+/tmp/

README.md

@@ -0,0 +1,27 @@
+# Owl
+```
+   ,_,
+  {o,o}
+  /)  )
+---"-"--
+```
+
+**TODO: Add description**
+
+## Installation
+
+If [available in Hex](https://hex.pm/docs/publish), the package can be installed
+by adding `owl` to your list of dependencies in `mix.exs`:
+
+```elixir
+def deps do
+  [
+    {:owl, "~> 0.1.0"}
+  ]
+end
+```
+
+Documentation can be generated with [ExDoc](https://github.com/elixir-lang/ex_doc)
+and published on [HexDocs](https://hexdocs.pm). Once published, the docs can
+be found at [https://hexdocs.pm/owl](https://hexdocs.pm/owl).
+

lib/owl.ex

@@ -0,0 +1,56 @@
+defmodule Owl do
+  def input(type, opts \\ []) do
+    value =
+      case String.trim(IO.gets(Keyword.fetch!(opts, :prompt) <> "\n")) do
+        "" -> nil
+        string -> string
+      end
+
+    cond do
+      not Keyword.get(opts, :allow_blank, false) and is_nil(value) ->
+        puts(Owl.Data.tag(:red, "Cannot be blank"))
+        input(type, opts)
+
+      true ->
+        value
+    end
+  end
+
+  def cmd(command, args, opts \\ []) do
+    log_shell_command(command, args)
+    System.cmd(command, args, opts)
+  end
+
+  def log_shell_command(command, args) do
+    command =
+      case args do
+        [] -> command
+        args -> "#{command} #{Enum.join(args, " ")}"
+      end
+
+    command = sanitize_passwords_in_urls(command)
+
+    puts(Owl.Data.tag(:light_black, "$ #{command}"))
+  end
+
+  def puts(content) do
+    content
+    |> Owl.Data.to_iodata()
+    |> IO.puts()
+  end
+
+  defp sanitize_passwords_in_urls(text) do
+    Regex.replace(~r/\w+:\/\/[^ ]+/, text, fn value ->
+      uri = URI.parse(value)
+
+      case uri.userinfo do
+        nil ->
+          value
+
+        userinfo ->
+          [username, _password] = String.split(userinfo, ":")
+          to_string(%{uri | userinfo: username <> ":********"})
+      end
+    end)
+  end
+end

lib/owl/data.ex

@@ -0,0 +1,228 @@
+defmodule Owl.Data do
+  def tag(sequences, data) do
+    Owl.Data.Tag.new(sequences, data)
+  end
+
+  @box_symbols %{
+    top_left: "┌",
+    top: "─",
+    top_right: "┐",
+    right: "│",
+    left: "│",
+    bottom_left: "└",
+    bottom: "─",
+    bottom_right: "┘"
+  }
+  def box(data, opts \\ []) do
+    padding_top = Keyword.get(opts, :padding_top, 0)
+    padding_bottom = Keyword.get(opts, :padding_bottom, 0)
+    padding_left = Keyword.get(opts, :padding_left, 2)
+    padding_right = Keyword.get(opts, :padding_right, 2)
+
+    lines =
+      (List.duplicate([], padding_top) ++ split(data, "\n") ++ List.duplicate([], padding_bottom))
+      |> Enum.map(&{&1, Owl.Data.length(&1)})
+
+    max_line_length = lines |> Enum.map(&elem(&1, 1)) |> Enum.max()
+
+    [
+      @box_symbols.top_left,
+      String.duplicate(@box_symbols.top, max_line_length + padding_left + padding_right),
+      @box_symbols.top_right,
+      "\n",
+      lines
+      |> Enum.map(fn {line, length} ->
+        [
+          @box_symbols.left,
+          String.duplicate(" ", padding_left),
+          line,
+          String.duplicate(" ", max_line_length - length + padding_right),
+          @box_symbols.right
+        ]
+      end)
+      |> Enum.intersperse("\n"),
+      "\n",
+      @box_symbols.bottom_left,
+      String.duplicate(@box_symbols.bottom, max_line_length + padding_left + padding_right),
+      @box_symbols.bottom_right
+    ]
+  end
+
+  def length(data) when is_binary(data) do
+    String.length(data)
+  end
+
+  def length(data) when is_list(data) do
+    Enum.reduce(data, 0, fn item, acc -> Owl.Data.length(item) + acc end)
+  end
+
+  def length(%Owl.Data.Tag{data: data}) do
+    Owl.Data.length(data)
+  end
+
+  def add_prefix(data, prefix) do
+    data
+    |> split("\n")
+    |> Enum.map(fn line ->
+      [prefix, line]
+    end)
+    |> Enum.intersperse("\n")
+  end
+
+  def to_iodata(data) do
+    data
+    |> split("\n")
+    |> Enum.intersperse("\n")
+    |> do_to_iodata(%{foreground: :default_color, background: :default_background})
+    |> IO.ANSI.format()
+  end
+
+  defp do_to_iodata(
+         %Owl.Data.Tag{sequences: sequences, data: data},
+         %{foreground: fg, background: bg}
+       ) do
+    parent_sequences = Enum.reject([fg, bg], &is_nil/1)
+
+    [
+      sequences,
+      do_to_iodata(data, sequences_to_state(parent_sequences ++ sequences)),
+      parent_sequences
+    ]
+  end
+
+  defp do_to_iodata([head | tail], state) do
+    [do_to_iodata(head, state) | do_to_iodata(tail, state)]
+  end
+
+  defp do_to_iodata(term, _state), do: term
+
+  defp maybe_wrap_to_tag([], [element]), do: element
+  defp maybe_wrap_to_tag([], data), do: data
+
+  defp maybe_wrap_to_tag(sequences1, [%Owl.Data.Tag{sequences: sequences2, data: data}]) do
+    Owl.Data.Tag.new(collapse_sequences(sequences1 ++ sequences2), data)
+  end
+
+  defp maybe_wrap_to_tag(sequences, data) do
+    Owl.Data.Tag.new(collapse_sequences(sequences), data)
+  end
+
+  defp reverse_and_tag(sequences, [%Owl.Data.Tag{sequences: last_sequences} | _] = data) do
+    maybe_wrap_to_tag(sequences -- last_sequences, Enum.reverse(data))
+  end
+
+  defp reverse_and_tag(sequences, data) do
+    maybe_wrap_to_tag(sequences, Enum.reverse(data))
+  end
+
+  # last write wins
+  defp collapse_sequences(sequences) do
+    sequences
+    |> sequences_to_state()
+    |> Map.values()
+    |> Enum.reject(&is_nil/1)
+  end
+
+  def split(data, pattern), do: split(data, pattern, [])
+  defp split([], _pattern, _acc_sequences), do: []
+
+  defp split(data, pattern, acc_sequences) do
+    case do_split(data, pattern, [], acc_sequences) do
+      {before_pattern, after_pattern, []} ->
+        [
+          reverse_and_tag(acc_sequences, before_pattern)
+          | split(after_pattern, pattern, acc_sequences)
+        ]
+
+      {before_pattern, after_pattern, next_acc_sequences} ->
+        [
+          reverse_and_tag(acc_sequences ++ next_acc_sequences, before_pattern)
+          | split(after_pattern, pattern, next_acc_sequences)
+        ]
+    end
+  end
+
+  defp do_split([head | tail], pattern, acc, acc_sequences) do
+    case do_split(head, pattern, acc, acc_sequences) do
+      {new_head, [], new_acc_sequences} ->
+        do_split(tail, pattern, new_head, new_acc_sequences)
+
+      {new_head, new_tail, new_acc_sequences} ->
+        new_tail = maybe_wrap_to_tag(new_acc_sequences -- acc_sequences, new_tail)
+
+        new_acc_sequences =
+          case new_head do
+            [%Owl.Data.Tag{sequences: sequences} | _] -> new_acc_sequences -- sequences
+            _ -> new_acc_sequences
+          end
+
+        new_head =
+          case new_head do
+            [%Owl.Data.Tag{data: []} | rest] -> rest
+            list -> list
+          end
+
+        {new_head, [new_tail | tail], new_acc_sequences}
+    end
+  end
+
+  defp do_split([], _pattern, acc, acc_sequences) do
+    {acc, [], acc_sequences}
+  end
+
+  defp do_split(
+         %Owl.Data.Tag{sequences: sequences, data: data},
+         pattern,
+         acc,
+         acc_sequences
+       ) do
+    {before_pattern, after_pattern, next_acc_sequences} =
+      do_split(data, pattern, [], acc_sequences ++ sequences)
+
+    before_pattern = reverse_and_tag(sequences, before_pattern)
+
+    next_acc_sequences =
+      case {before_pattern, after_pattern} do
+        {%Owl.Data.Tag{sequences: sequences}, []} -> next_acc_sequences -- sequences
+        {_, []} -> acc_sequences
+        {_, _} -> next_acc_sequences
+      end
+
+    {[before_pattern | acc], after_pattern, next_acc_sequences}
+  end
+
+  defp do_split(value, pattern, acc, acc_sequences) when is_binary(value) do
+    [head | tail] = String.split(value, pattern, parts: 2)
+
+    {
+      case head do
+        "" -> acc
+        value -> [value | acc]
+      end,
+      tail,
+      acc_sequences
+    }
+  end
+
+  defp sequences_to_state(sequences) do
+    Enum.reduce(sequences, %{foreground: nil, background: nil}, fn sequence, acc ->
+      Map.put(acc, sequence_type(sequence), sequence)
+    end)
+  end
+
+  for color <- [:black, :red, :green, :yellow, :blue, :magenta, :cyan, :white] do
+    defp sequence_type(unquote(color)), do: :foreground
+    defp sequence_type(unquote(:"light_#{color}")), do: :foreground
+    defp sequence_type(unquote(:"#{color}_background")), do: :background
+    defp sequence_type(unquote(:"light_#{color}_background")), do: :background
+  end
+
+  defp sequence_type(:default_color), do: :foreground
+  defp sequence_type(:default_background), do: :background
+
+  # https://github.com/elixir-lang/elixir/blob/74bfab8ee271e53d24cb0012b5db1e2a931e0470/lib/elixir/lib/io/ansi.ex#L73
+  defp sequence_type("\e[38;5;" <> _), do: :foreground
+
+  # https://github.com/elixir-lang/elixir/blob/74bfab8ee271e53d24cb0012b5db1e2a931e0470/lib/elixir/lib/io/ansi.ex#L87
+  defp sequence_type("\e[48;5;" <> _), do: :background
+end

lib/owl/data/tag.ex

@@ -0,0 +1,11 @@
+defmodule Owl.Data.Tag do
+  defstruct sequences: [], data: []
+
+  @doc false
+  def new(sequences, data) do
+    %__MODULE__{
+      sequences: List.wrap(sequences),
+      data: data
+    }
+  end
+end

lib/owl/io.ex

@@ -0,0 +1,9 @@
+defmodule Owl.IO do
+  def inspect(data) do
+    ["\n", data, "\n"]
+    |> Owl.Data.to_iodata()
+    |> Owl.puts()
+
+    data
+  end
+end

mix.exs

@@ -0,0 +1,27 @@
+defmodule Owl.MixProject do
+  use Mix.Project
+
+  def project do
+    [
+      app: :owl,
+      version: "0.1.0",
+      elixir: "~> 1.12",
+      start_permanent: Mix.env() == :prod,
+      deps: deps()
+    ]
+  end
+
+  # Run "mix help compile.app" to learn about applications.
+  def application do
+    [
+      extra_applications: [:logger]
+    ]
+  end
+
+  # Run "mix help deps" to learn about dependencies.
+  defp deps do
+    [
+      {:ex_doc, "~> 0.24", only: :dev, runtime: false}
+    ]
+  end
+end