Refactor

Author: RoyalIcing

apps/components_guide_web/lib/components_guide_web/controllers/universal_modules_controller.ex

@@ -1,100 +1,146 @@
 defmodule ComponentsGuideWeb.UniversalModulesController do
   use ComponentsGuideWeb, :controller
 
+  alias ComponentsGuideWeb.UniversalModulesParser, as: Parser
+
   def index(conn, _params) do
     source = "
     const pi = 3.14;
 
     const answer = 42;
+    const negativeAnswer = -42;
+
+    const isEnabled = true;
+    const verbose = false;
     "
-    decoded = decode_module(source)
-    render(conn, "index.html", source: source, decoded: inspect(decoded))
+    # decoded = decode_module(source)
+    decoded = Parser.decode(source)
+
+    render(conn, "index.html",
+      page_title: "Universal Modules",
+      source: source,
+      decoded: inspect(decoded)
+    )
   end
+end
 
-  defp decode_module(source) do
-    decode_module(nil, source, [])
+defmodule ComponentsGuideWeb.UniversalModulesParser do
+  def switch(submodule, input, result) do
+    mod = Module.concat(__MODULE__, submodule)
+    apply(mod, :decode, [input, result])
   end
 
-  defp decode_module(nil, <<"\n", rest::bitstring>>, result),
-    do: decode_module(nil, rest, result)
+  def decode(input), do: switch(Root, input, [])
 
-  # Skip semicolons
-  defp decode_module(nil, <<";", rest::bitstring>>, result),
-    do: decode_module(nil, rest, result)
+  defmodule Root do
+    def decode("", result), do: {:ok, Enum.reverse(result)}
+    def decode(<<"\n", rest::bitstring>>, result), do: decode(rest, result)
+    def decode(<<" ", rest::bitstring>>, result), do: decode(rest, result)
+    def decode(<<";", rest::bitstring>>, result), do: decode(rest, result)
 
-  # Skip semicolons
-  defp decode_module(nil, <<" ", rest::bitstring>>, result),
-    do: decode_module(nil, rest, result)
+    def decode(<<"const ", rest::bitstring>>, result) do
+      ComponentsGuideWeb.UniversalModulesParser.switch(Const, rest, result)
+    end
 
-  defp decode_module(nil, <<"const ", rest::bitstring>>, result) do
-    decode_module({:const, :expect_identifier, []}, rest, result)
+    def decode(input, result) do
+      {:err, :unexpected_eof, input, result}
+    end
   end
 
-  # Skip whitespace
-  defp decode_module({_, :expect_identifier, []} = context, <<" ", rest::bitstring>>, result),
-    do: decode_module(context, rest, result)
+  defmodule Const do
+    def decode(input, result) do
+      decode({:expect_identifier, []}, input, result)
+    end
 
-  # Skip whitespace
-  defp decode_module({_, :expect_expression, []} = context, <<" ", rest::bitstring>>, result),
-    do: decode_module(context, rest, result)
+    defp decode(
+           {:expect_identifier, _} = context,
+           <<" ", rest::bitstring>>,
+           result
+         ) do
+      decode(context, rest, result)
+    end
 
-  defp decode_module(
-         {:const, :expect_identifier, _} = context,
-         <<" ", rest::bitstring>>,
-         result
-       ) do
-    decode_module(context, rest, result)
-  end
+    defp decode(
+           {:expect_identifier, reverse_identifier},
+           <<"=", rest::bitstring>>,
+           result
+         ) do
+      identifier = reverse_identifier |> Enum.reverse() |> :binary.list_to_bin()
+      decode({identifier, :expect_expression, []}, rest, result)
+    end
 
-  defp decode_module(
-         {:const, :expect_identifier, reverse_identifier},
-         <<"=", rest::bitstring>>,
-         result
-       ) do
-    identifier = reverse_identifier |> Enum.reverse() |> :binary.list_to_bin()
-    decode_module({{:const, identifier}, :expect_expression, []}, rest, result)
-  end
+    defp decode(
+           {:expect_identifier, reverse_identifier},
+           <<char::utf8, rest::bitstring>>,
+           result
+         ) do
+      decode({:expect_identifier, [char | reverse_identifier]}, rest, result)
+    end
 
-  defp decode_module(
-         {:const, :expect_identifier, reverse_identifier},
-         <<char::utf8, rest::bitstring>>,
-         result
-       ) do
-    decode_module({:const, :expect_identifier, [char | reverse_identifier]}, rest, result)
-  end
+    # Skip whitespace
+    defp decode({_, :expect_expression, []} = context, <<" ", rest::bitstring>>, result),
+      do: decode(context, rest, result)
+
+    defp decode(
+           {identifier, :expect_expression, expression},
+           <<";", rest::bitstring>>,
+           result
+         ),
+         do: Root.decode(rest, [{:const, identifier, expression} | result])
+
+    defp decode(
+           {identifier, :expect_expression, []},
+           <<"true", rest::bitstring>>,
+           result
+         ) do
+      decode({identifier, :expect_expression, [true]}, rest, result)
+    end
 
-  defp decode_module(
-         {{:const, identifier}, :expect_expression, expression},
-         <<";", rest::bitstring>>,
-         result
-       ),
-       do: decode_module(nil, rest, [{:const, identifier, expression} | result])
-
-  defp decode_module(
-         {{:const, identifier}, :expect_expression, []} = context,
-         <<char::utf8, _::bitstring>> = source,
-         result
-       )
-       when char in [?0, ?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9] do
-    case Float.parse(source) do
-      :error ->
-        err(context, source, result)
-
-      {f, rest} ->
-        decode_module({{:const, identifier}, :expect_expression, [f]}, rest, result)
+    defp decode(
+           {identifier, :expect_expression, []},
+           <<"false", rest::bitstring>>,
+           result
+         ) do
+      decode({identifier, :expect_expression, [false]}, rest, result)
     end
-  end
 
-  defp decode_module(nil, "", result) do
-    {:ok, Enum.reverse(result)}
-  end
+    defp decode(
+           {identifier, :expect_expression, []},
+           <<"null", rest::bitstring>>,
+           result
+         ) do
+      decode({identifier, :expect_expression, [nil]}, rest, result)
+    end
 
-  defp decode_module(context, source, result) do
-    err(context, source, result)
-  end
+    defp decode(
+           {identifier, :expect_expression, []} = context,
+           <<char::utf8, _::bitstring>> = source,
+           result
+         )
+         when char in '0123456789' do
+      case Float.parse(source) do
+        :error ->
+          {:err, context, source, result}
+
+        {f, rest} ->
+          decode({identifier, :expect_expression, [f]}, rest, result)
+      end
+    end
 
-  defp err(context, source, result) do
-    {:err, context, source, result}
+    defp decode(
+           {identifier, :expect_expression, []} = context,
+           <<"-", char::utf8, _::bitstring>> = source,
+           result
+         )
+         when char in '0123456789' do
+      case Float.parse(source) do
+        :error ->
+          {:err, context, source, result}
+
+        {f, rest} ->
+          decode({identifier, :expect_expression, [f]}, rest, result)
+      end
+    end
   end
 end