WIP color parser

	NEXT: Write regexp parser

lib/ex_aequo_colors/cli.ex

@@ -1,6 +1,6 @@
 defmodule ExAequoColors.Cli do
 
-  import ExAequoBase.Map, only: [put_if: 3]
+  # import ExAequoBase.Map, only: [put_if: 3]
   import ExAequoColors.Color, only: [color: 2]
   import ExAequoColors.Colorizer, only: [colorize: 2]
   import ExAequoBase.Io, only: [numbered_lines: 1]
@@ -56,9 +56,9 @@ defmodule ExAequoColors.Cli do
 
     defp run(stream, options) do
       stream
-        |> numbered_lines()
-        |> Stream.map(&_colorize_line(&1, options))
-        |> Enum.join("\n") 
+      |> numbered_lines()
+      |> Stream.map(&_colorize_line(&1, options))
+      |> Enum.join("\n") 
     end
 
     defp _add_defaults(options) do
@@ -113,6 +113,14 @@ defmodule ExAequoColors.Cli do
       end
     end
 
+    defp put_if(map, key, pairs) do
+      if Map.get(map, key) do
+        pairs
+        |> Enum.inject(map, fn {k, v}, a -> Map.put(a, k, v) end) 
+      else
+        map
+      end
+    end
     @spec _version() :: binary()
     defp _version do
       with {:ok, version} <- :application.get_key(:ex_aequo_colors, :vsn),

lib/ex_aequo_colors/colorizer.ex

@@ -28,12 +28,13 @@ defmodule ExAequoColors.Colorizer do
     closer = Map.get(options, :closer)
     escaper = String.at(trigger, 0)
     regexen = _compile_regexen(options)
-    case _parse(line, [], options, regexen) do
-      {:ok, result} -> {:ok, result <> reset}
-      error -> error
-    end
+    # case _parse(line, [], options, regexen) do
+    #   {:ok, result} -> {:ok, result <> reset}
+    #   error -> error
+    # end
   end
 
+  defp _compile_color(_), do: :color
   @spec _compile_regexen(map()) :: list(Regex.t())
   defp _compile_regexen(options) do
     [
@@ -48,12 +49,12 @@ defmodule ExAequoColors.Colorizer do
   @spec _compile_double_escape(map(), atom()) :: Regex.t()
   defp _compile_double_escape(options, key) do
     trigger = Map.get(options, key) |> String.at(0)
-    rgx_trigger = Regex.escape(trigger)
+    trigger_rgx = Regex.escape(trigger)
     rgx = Regex.compile!("\\A(#{trigger_rgx})#{trigger_rgx}")
     {rgx, trigger}
   end
 
-  @spec _compile_literal(map(), atom()) :: Regex.t()
+  @spec _compile_literal(map(), atom(), any()) :: Regex.t()
   defp _compile_literal(options, key, fun) do
     literal = Map.get(options, key)
     {Regex.compile!("\\A(#{Regex.escape(literal)})"), fun}
@@ -69,59 +70,59 @@ defmodule ExAequoColors.Colorizer do
     {rgx, nil}
   end
 
-  @spec _parse(binary(), list(), map()) :: color_t()
-  defp _parse(line, result, options)
-  defp _parse("", result, _) do
-    {:ok, IO.chardata_to_string(result)}
-  end
-  defp _parse(input, result, options) do
-    select([
-      _parse_escaped_trigger_fn(input, result, options),
-      _parse_escaped_resetter_fn(input, result, options),
-      _parse_verbatim_fn(input, result, options),
-    ])
-  end
-
-  @spec _parse_escaped(binary(), list(), map(), binary()) :: color_t()
-  defp _parse_escaped(input, result, options, toescape) do
-    first_trigger = String.at(toescape, 0)
-    escaped_trigger = first_trigger <> first_trigger
-    if String.starts_with?(input, escaped_trigger) do
-      _parse(behead(input, 2), [result, first_trigger], options)
-    end
-  end
-
-  @spec _parse_escaped_resetter_fn(binary(), list(), map()) :: color_fn_t()
-  defp _parse_escaped_resetter_fn(input, result, options) do
-    fn ->
-      case Map.get(options, :resetter) do
-        nil -> nil 
-        resetter -> _parse_escaped(input, result, options, resetter)
-      end
-    end
-  end
-
-  @spec _parse_escaped_trigger_fn(binary(), list(), map()) :: color_fn_t() 
-  defp _parse_escaped_trigger_fn(input, result, options) do
-    fn -> 
-      _parse_escaped(input, result, options, options.trigger)
-    end
-  end
-
-  @spec _parse_verbatim(binary(), list(), map()) :: color_t()
-  defp _parse_verbatim(input, result, options) do
-    case parse_up_to(input, options.non_verb, :keep) do
+#   @spec _parse(binary(), list(), map()) :: color_t()
+#   defp _parse(line, result, options)
+#   defp _parse("", result, _) do
+#     {:ok, IO.chardata_to_string(result)}
+#   end
+#   defp _parse(input, result, options) do
+#     select([
+#       _parse_escaped_trigger_fn(input, result, options),
+#       _parse_escaped_resetter_fn(input, result, options),
+#       _parse_verbatim_fn(input, result, options),
+#     ])
+#   end
+
+#   @spec _parse_escaped(binary(), list(), map(), binary()) :: color_t()
+#   defp _parse_escaped(input, result, options, toescape) do
+#     first_trigger = String.at(toescape, 0)
+#     escaped_trigger = first_trigger <> first_trigger
+#     if String.starts_with?(input, escaped_trigger) do
+#       _parse(behead(input, 2), [result, first_trigger], options)
+#     end
+#   end
+
+#   @spec _parse_escaped_resetter_fn(binary(), list(), map()) :: color_fn_t()
+#   defp _parse_escaped_resetter_fn(input, result, options) do
+#     fn ->
+#       case Map.get(options, :resetter) do
+#         nil -> nil 
+#         resetter -> _parse_escaped(input, result, options, resetter)
+#       end
+#     end
+#   end
+
+#   @spec _parse_escaped_trigger_fn(binary(), list(), map()) :: color_fn_t() 
+#   defp _parse_escaped_trigger_fn(input, result, options) do
+#     fn -> 
+#       _parse_escaped(input, result, options, options.trigger)
+#     end
+#   end
+
+#   @spec _parse_verbatim(binary(), list(), map()) :: color_t()
+#   defp _parse_verbatim(input, result, options) do
+#     case parse_up_to(input, options.non_verb, :keep) do
 
-    end
+#     end
 
-  end
-
-  @spec _parse_verbatim_fn(binary(), list(), map()) :: color_fn_t()
-  defp _parse_verbatim_fn(input, result, options) do
-    fn ->
-      _parse_verbatim(input, result, options)
-    end
-  end
+#   end
+
+#   @spec _parse_verbatim_fn(binary(), list(), map()) :: color_fn_t()
+#   defp _parse_verbatim_fn(input, result, options) do
+#     fn ->
+#       _parse_verbatim(input, result, options)
+#     end
+#   end
   # defp _colorize_line({line, lnb}, auto) do
   #   case line |>_parse(auto, []) do
   #     {:ok, result} -> {:ok, IO.chardata_to_string(result)}