Delete unused components

lib/dsl.ex

@@ -15,18 +15,10 @@ defmodule Strom.DSL do
     defstruct splitter: nil, opts: [], input: nil, partitions: %{}
   end
 
-  defmodule Function do
-    defstruct function: nil, opts: [], inputs: []
-  end
-
   defmodule Transform do
     defstruct function: nil, acc: nil, inputs: [], call: nil
   end
 
-  defmodule Module do
-    defstruct module: nil, opts: [], inputs: [], state: nil
-  end
-
   defmodule Rename do
     defstruct names: nil, rename: nil
   end
@@ -75,16 +67,6 @@ defmodule Strom.DSL do
     end
   end
 
-  defmacro function(inputs, function, opts \\ []) do
-    quote do
-      %Strom.DSL.Function{
-        function: unquote(function),
-        opts: unquote(opts),
-        inputs: unquote(inputs)
-      }
-    end
-  end
-
   defmacro transform(inputs, function, acc) do
     quote do
       %Strom.DSL.Transform{
@@ -105,16 +87,6 @@ defmodule Strom.DSL do
     end
   end
 
-  defmacro module(inputs, module, opts \\ []) do
-    quote do
-      %Strom.DSL.Module{
-        module: unquote(module),
-        opts: unquote(opts),
-        inputs: unquote(inputs)
-      }
-    end
-  end
-
   defmacro from(module, opts \\ []) do
     quote do
       unless is_atom(unquote(module)) do

lib/flow.ex

@@ -46,16 +46,9 @@ defmodule Strom.Flow do
         %DSL.Splitter{opts: opts} = splitter ->
           %{splitter | splitter: Strom.Splitter.start(opts)}
 
-        %DSL.Function{function: function, opts: opts} = fun ->
-          %{fun | function: Strom.Function.start(function, opts)}
-
         %DSL.Transform{} = fun ->
           %{fun | call: Strom.Transformer.start()}
 
-        %DSL.Module{module: module, opts: opts} = mod ->
-          module = Strom.Module.start(module, opts)
-          %{mod | module: module}
-
         %DSL.Rename{names: names} = ren ->
           rename = Strom.Renamer.start(names)
           %{ren | rename: rename}
@@ -93,19 +86,13 @@ defmodule Strom.Flow do
           %DSL.Splitter{splitter: splitter, input: input, partitions: partitions} ->
             Strom.Splitter.call(flow, splitter, input, partitions)
 
-          %DSL.Function{function: function, inputs: inputs} ->
-            Strom.Function.call(flow, function, inputs)
-
           %DSL.Transform{call: call, function: function, acc: acc, inputs: inputs} ->
             if is_function(function, 2) do
               Strom.Transformer.call(flow, call, inputs, {function, acc})
             else
               Strom.Transformer.call(flow, call, inputs, function)
             end
 
-          %DSL.Module{module: module, inputs: inputs} ->
-            Strom.Module.call(flow, module, inputs)
-
           %DSL.Rename{rename: rename, names: names} ->
             Strom.Renamer.call(flow, rename, names)
         end
@@ -130,14 +117,8 @@ defmodule Strom.Flow do
         %DSL.Splitter{splitter: splitter} ->
           Strom.Splitter.stop(splitter)
 
-        %DSL.Function{function: function} ->
-          Strom.Function.stop(function)
-
         %DSL.Transform{call: call} ->
           Strom.Transformer.stop(call)
-
-        %DSL.Module{module: module} ->
-          Strom.Module.stop(module)
       end
     end)
 

lib/transformer.ex

@@ -28,7 +28,9 @@ defmodule Strom.Transformer do
   end
 
   def call(flow, %__MODULE__{} = call, names, {function, acc})
-      when is_map(flow) and is_list(names) and is_function(function, 3) do
+      when is_map(flow) and is_function(function, 3) do
+    names = if is_list(names), do: names, else: [names]
+
     input_streams =
       Enum.reduce(names, %{}, fn name, streams ->
         Map.put(streams, {name, function, acc}, Map.fetch!(flow, name))
@@ -72,13 +74,13 @@ defmodule Strom.Transformer do
   end
 
   def call(flow, %__MODULE__{} = call, names, {function, acc})
-      when is_map(flow) and is_list(names) and is_function(function, 2) do
+      when is_map(flow) and is_function(function, 2) do
     fun = fn el, acc, nil -> function.(el, acc) end
     call(flow, %__MODULE__{} = call, names, {fun, acc})
   end
 
   def call(flow, %__MODULE__{} = call, names, function)
-      when is_map(flow) and is_list(names) and is_function(function, 1) do
+      when is_map(flow) and is_function(function, 1) do
     fun = fn el, nil, nil -> {[function.(el)], nil} end
     call(flow, %__MODULE__{} = call, names, {fun, nil})
   end