improvement!: Store inputs in their own struct

Author: jimsynz

lib/reactor.ex

@@ -44,7 +44,6 @@ defmodule Reactor do
   defstruct context: %{},
             description: nil,
             id: nil,
-            input_descriptions: %{},
             inputs: [],
             intermediate_results: %{},
             middleware: [],
@@ -144,8 +143,7 @@ defmodule Reactor do
           context: context,
           description: nil | String.t(),
           id: any,
-          input_descriptions: %{atom => String.t()},
-          inputs: [atom],
+          inputs: [Reactor.Input.t()],
           intermediate_results: %{any => any},
           middleware: [Reactor.Middleware.t()],
           plan: nil | Graph.t(),

lib/reactor/builder/compose.ex

@@ -138,7 +138,7 @@ defmodule Reactor.Builder.Compose do
   end
 
   defp reactor_inputs(reactor) when is_struct(reactor),
-    do: {:ok, MapSet.new(reactor.inputs)}
+    do: {:ok, MapSet.new(reactor.inputs, & &1.name)}
 
   defp reactor_inputs(reactor) when is_atom(reactor) do
     with {:ok, reactor} <- Reactor.Info.to_struct(reactor) do

lib/reactor/builder/input.ex

@@ -43,38 +43,34 @@ defmodule Reactor.Builder.Input do
   @doc """
   Add a named input to the reactor.
   """
-  @spec add_input(Reactor.t(), any, options) :: {:ok, Reactor.t()} | {:error, any}
-  def add_input(reactor, name, options) do
-    case validate_options(options) do
-      {:ok, options} when is_nil(options.transform) ->
-        reactor =
-          reactor
-          |> do_add_input(name)
-          |> maybe_add_description(name, options.description)
+  @spec add_input(Reactor.t(), any, options | transform) :: {:ok, Reactor.t()} | {:error, any}
+  def add_input(reactor, name, nil), do: add_input(reactor, name, [])
 
-        {:ok, reactor}
-
-      {:ok, options} ->
-        reactor =
-          reactor
-          |> do_add_input(name)
-          |> add_input_transform(name, options.transform)
-          |> maybe_add_description(name, options.description)
-
-        {:ok, reactor}
+  def add_input(reactor, name, options) when is_list(options) do
+    with {:ok, options} <- Spark.Options.validate(options, @options) do
+      reactor =
+        reactor
+        |> do_add_input(name, options)
+        |> maybe_add_input_transform(name, options[:transform])
 
-      {:error, reason} ->
-        {:error, reason}
+      {:ok, reactor}
     end
   end
 
-  defp do_add_input(reactor, name), do: %{reactor | inputs: [name | reactor.inputs]}
-  defp maybe_add_description(reactor, _name, nil), do: reactor
+  def add_input(reactor, name, transform), do: add_input(reactor, name, transform: transform)
+
+  defp do_add_input(reactor, name, options) do
+    input = %Reactor.Input{
+      name: name,
+      description: options[:description]
+    }
+
+    %{reactor | inputs: [input | reactor.inputs]}
+  end
 
-  defp maybe_add_description(reactor, name, description),
-    do: %{reactor | input_descriptions: Map.put(reactor.input_descriptions, name, description)}
+  defp maybe_add_input_transform(reactor, _name, nil), do: reactor
 
-  defp add_input_transform(reactor, name, {module, options} = transform)
+  defp maybe_add_input_transform(reactor, name, {module, options} = transform)
        when is_atom(module) and is_list(options) do
     transform_step = %Step{
       arguments: [Argument.from_input(:value, name)],
@@ -89,14 +85,6 @@ defmodule Reactor.Builder.Input do
     %{reactor | steps: [transform_step | reactor.steps]}
   end
 
-  defp add_input_transform(reactor, name, transform),
-    do: add_input_transform(reactor, name, {Step.Transform, fun: transform})
-
-  defp validate_options(options) when is_list(options) do
-    with {:ok, options} <- Spark.Options.validate(options, @options) do
-      {:ok, Map.new(options)}
-    end
-  end
-
-  defp validate_options(transform), do: validate_options(transform: transform)
+  defp maybe_add_input_transform(reactor, name, transform),
+    do: maybe_add_input_transform(reactor, name, {Step.Transform, fun: transform})
 end

lib/reactor/executor/init.ex

@@ -51,11 +51,11 @@ defmodule Reactor.Executor.Init do
   end
 
   defp validate_inputs(reactor, inputs) do
-    valid_input_names = MapSet.new(reactor.inputs)
+    valid_input_names = MapSet.new(reactor.inputs, & &1.name)
     provided_input_names = inputs |> Map.keys() |> MapSet.new()
 
     if MapSet.subset?(valid_input_names, provided_input_names) do
-      {:ok, Map.take(inputs, reactor.inputs)}
+      {:ok, Map.take(inputs, Enum.to_list(valid_input_names))}
     else
       missing_inputs =
         valid_input_names

lib/reactor/input.ex

@@ -0,0 +1,16 @@
+# SPDX-FileCopyrightText: 2023 James Harton, Zach Daniel, Alembic Pty and contributors
+# SPDX-FileCopyrightText: 2023 reactor contributors <https://github.com/ash-project/reactor/graphs.contributors>
+#
+# SPDX-License-Identifier: MIT
+
+defmodule Reactor.Input do
+  @moduledoc """
+  Reactor's internal representation for inputs.
+  """
+  defstruct [:name, :description]
+
+  @type t :: %__MODULE__{
+          name: atom,
+          description: nil | String.t()
+        }
+end

lib/reactor/mermaid/reactor.ex

@@ -57,24 +57,24 @@ defmodule Reactor.Mermaid.Reactor do
     |> map_while_ok(&generate_input(&1, reactor, options))
   end
 
-  defp generate_input(input_name, reactor, options) do
-    id = mermaid_id({reactor.id, input_name}, :input)
+  defp generate_input(input, reactor, options) do
+    id = mermaid_id({reactor.id, input.name}, :input)
 
     content =
       if options[:describe?] do
         [
           id,
           ">\"`",
           "**Input ",
-          to_string(input_name),
+          to_string(input.name),
           "**",
           "\n",
-          md_escape(Map.get(reactor.input_descriptions, input_name)),
+          md_escape(input.description),
           "`\"]",
           "\n"
         ]
       else
-        [id, ">\"Input ", to_string(input_name), "\"]\n"]
+        [id, ">\"Input ", to_string(input.name), "\"]\n"]
       end
 
     {:ok, %Node{id: id, pre: content}}

lib/reactor/step/around/mermaid.ex

@@ -20,7 +20,7 @@ defmodule Reactor.Step.Around.Mermaid do
       links =
         reactor.inputs
         |> Enum.map(fn input ->
-          [node.id, "-->", mermaid_id({reactor.id, input}, :input), "\n"]
+          [node.id, "-->", mermaid_id({reactor.id, input.name}, :input), "\n"]
         end)
         |> Enum.concat([inner_return_id, "-->", node.id, "\n"])
 

lib/reactor/step/compose/mermaid.ex

@@ -28,7 +28,7 @@ defmodule Reactor.Step.Compose.Mermaid do
       links =
         reactor.inputs
         |> Enum.map(fn input ->
-          [node.id, "-->", mermaid_id({reactor.id, input}, :input), "\n"]
+          [node.id, "-->", mermaid_id({reactor.id, input.name}, :input), "\n"]
         end)
         |> Enum.concat([inner_return_id, "-->", node.id, "\n"])
 

lib/reactor/step/group/mermaid.ex

@@ -20,7 +20,7 @@ defmodule Reactor.Step.Group.Mermaid do
       links =
         reactor.inputs
         |> Enum.map(fn input ->
-          [node.id, "-->", mermaid_id({reactor.id, input}, :input), "\n"]
+          [node.id, "-->", mermaid_id({reactor.id, input.name}, :input), "\n"]
         end)
         |> Enum.concat([inner_return_id, "-->", node.id, "\n"])
 

lib/reactor/step/map/mermaid.ex

@@ -25,7 +25,7 @@ defmodule Reactor.Step.Map.Mermaid do
       links =
         reactor.inputs
         |> Enum.map(fn input ->
-          [node.id, "-->", mermaid_id({reactor.id, input}, :input), "\n"]
+          [node.id, "-->", mermaid_id({reactor.id, input.name}, :input), "\n"]
         end)
         |> Enum.concat([inner_return_id, "-->", node.id, "\n"])