feat: ✨ update CLI

Author: maxbarsukov

lib/cli/config_parser.ex

@@ -3,41 +3,33 @@ defmodule InterpolationApp.CLI.ConfigParser do
   Parses args for interpolation-app CLI
   """
 
-  @methods ["linear", "lagrange2", "lagrange3", "newton"]
+  @methods ["linear", "lagrange3", "lagrange4", "newton"]
 
   def parse_args(args) do
     args
     |> Enum.reduce(%{}, &parse_arg/2)
     |> validate_args()
   end
 
-  defp parse_arg("--method1=" <> method, acc) do
-    Map.put(acc, :method1, String.trim(method))
+  defp parse_arg("methods=" <> method, acc) do
+    Map.put(acc, :methods, String.split(String.trim(method), ","))
   end
 
-  defp parse_arg("--method2=" <> method, acc) do
-    Map.put(acc, :method2, String.trim(method))
-  end
-
-  defp parse_arg("--step=" <> step, acc) do
+  defp parse_arg("step=" <> step, acc) do
     Map.put(acc, :step, String.trim(step))
   end
 
-  defp parse_arg("--accuracy=" <> accuracy, acc) do
+  defp parse_arg("accuracy=" <> accuracy, acc) do
     Map.put(acc, :accuracy, String.trim(accuracy))
   end
 
   defp parse_arg(_, acc), do: acc
 
-  defp validate_args(%{method1: method1, method2: method2, step: step, accuracy: accuracy}) do
+  defp validate_args(%{methods: methods, step: step, accuracy: accuracy}) do
     cond do
-      !valid_method?(method1) ->
+      !valid_methods?(methods) ->
         {:error,
-         "Неправильный method1: #{method1}. Должен быть один из [#{Enum.join(@methods, ", ")}]."}
-
-      !valid_method?(method2) ->
-        {:error,
-         "Неправильный method2: #{method2}. Должен быть один из [#{Enum.join(@methods, ", ")}]."}
+         "Неправильный ввод методов: Методы должны быть перечислены через запятую и не повторяться.\nМетод должен быть один из [#{Enum.join(@methods, ", ")}]."}
 
       !valid_step?(step) ->
         {:error,
@@ -49,23 +41,24 @@ defmodule InterpolationApp.CLI.ConfigParser do
       true ->
         {:ok,
          %{
-           method1: module_from_method(method1),
-           method2: module_from_method(method2),
+           methods: Enum.map(methods, &module_from_method/1),
            step: elem(Float.parse(step), 0),
            accuracy: elem(Integer.parse(accuracy), 0)
          }}
     end
   end
 
-  defp validate_args(%{method1: method1, method2: method2, step: step}) do
-    validate_args(%{method1: method1, method2: method2, step: step, accuracy: "3"})
+  defp validate_args(%{methods: methods, step: step}) do
+    validate_args(%{methods: methods, step: step, accuracy: "3"})
   end
 
   defp validate_args(_) do
-    {:error, "Ошибка! Обязательные аргументы: --method1=, --method2=, --step="}
+    {:error, "Ошибка! Обязательные аргументы: --methods=, --step="}
   end
 
-  defp valid_method?(method), do: method in @methods
+  defp valid_methods?(methods) do
+    Enum.uniq(methods) == methods and Enum.all?(methods, fn method -> method in @methods end)
+  end
 
   defp valid_step?(step) do
     case Float.parse(step) do

lib/cli/interpolator.ex

@@ -27,22 +27,34 @@ defmodule InterpolationApp.CLI.Interpolator do
   @impl true
   def handle_cast({:add_point, point}, {points, config, printer_pid}) do
     points = Enum.reverse([point | Enum.reverse(points)])
-    methods = Enum.uniq([config.method1, config.method2])
-
-    Enum.each(methods, fn method ->
-      if method.points_enough?(points) do
-        limit = method.get_enough_points_count()
-        interpolation_points = Enum.slice(points, -limit, limit)
-        generated_points = PointGenerator.generate(interpolation_points, config.step)
-
-        GenServer.cast(printer_pid, {
-          :print,
-          method,
-          method.interpolate(interpolation_points, generated_points)
-        })
-      end
+
+    Enum.each(config.methods, fn method ->
+      handle_method(method, points, printer_pid, config)
     end)
 
     {:noreply, {points, config, printer_pid}}
   end
+
+  # Helper Functions
+
+  defp handle_method(method, points, printer_pid, config) do
+    if method.points_enough?(points) do
+      limit = method.get_enough_points_count()
+
+      interpolation_points =
+        if method.need_concrete_number_of_points?(),
+          do: Enum.slice(points, -limit, limit),
+          else: points
+
+      generated_points = PointGenerator.generate(interpolation_points, config.step)
+
+      GenServer.cast(printer_pid, {
+        :print,
+        method,
+        method.interpolate(interpolation_points, generated_points)
+      })
+    end
+
+    :ok
+  end
 end

lib/cli/printer.ex

@@ -34,7 +34,7 @@ defmodule InterpolationApp.CLI.Printer do
     {first_x, _} = List.first(result)
 
     IO.puts(
-      "#{method.get_name()} (идем от точки из введенных #{first_x} с шагом #{step}, покрывая все введенные X)"
+      ">> #{method.get_name()} (идем от точки из введенных #{first_x} с шагом #{step}, покрывая все введенные X)"
     )
 
     print_line(result, accuracy)

lib/cli/repl.ex

@@ -19,22 +19,36 @@ defmodule InterpolationApp.CLI.Repl do
 
   defp loop(applier_pid) do
     :io.setopts(:standard_io, active: true)
-    input = IO.gets("")
+    input = IO.gets("") |> check_quit
 
-    if input == :eof or String.trim(input) == "quit" do
-      IO.puts("\nСпасибо за использование программы!\n")
+    GenServer.cast(applier_pid, {:apply_input, String.trim(input)})
+    loop(applier_pid)
+  end
 
-      IO.puts("""
-            |\      _,,,---,,_
-      ZZZzz /,`.-'`'    -.  ;-;;,_
-          |,4-  ) )-,_. ,\ (  `'-'
-          '---''(_/--'  `-'\_)
-      """)
+  defp check_quit(input) do
+    if input == :eof do
+      :timer.sleep(100)
+      quit()
+    end
 
-      System.halt()
+    if String.trim(input) == "quit" do
+      quit()
     end
 
-    GenServer.cast(applier_pid, {:apply_input, String.trim(input)})
-    loop(applier_pid)
+    input
+  end
+
+  @spec quit() :: no_return()
+  defp quit do
+    IO.puts("\nСпасибо за использование программы!\n")
+
+    IO.puts("""
+          |\      _,,,---,,_
+    ZZZzz /,`.-'`'    -.  ;-;;,_
+        |,4-  ) )-,_. ,\ (  `'-'
+        '---''(_/--'  `-'\_)
+    """)
+
+    System.halt()
   end
 end

lib/main.ex

@@ -12,7 +12,12 @@ defmodule InterpolationApp.Main do
       System.halt()
     end
 
-    case ConfigParser.parse_args(args) do
+    argv =
+      Enum.map(args, fn arg -> String.split(arg, "--") end)
+      |> List.flatten()
+      |> Enum.filter(fn s -> s != "" end)
+
+    case ConfigParser.parse_args(argv) do
       {:ok, config} ->
         Repl.start(config)
 
@@ -25,15 +30,15 @@ defmodule InterpolationApp.Main do
 
   defp help do
     """
-    usage: interpolation-app [options] --method1=<method> --method2=<method> --step=<step>
+    usage: interpolation-app [options] --methods=<method1,method2,...> --step=<step>
     options:
       -h, --help              Prints this message
       --accuracy=<accuracy>   Set printing accuracy
 
     methods:
       * linear
-      * lagrange2
       * lagrange3
+      * lagrange4
       * newton
     """
   end