use_case_chain.rb in eco-helpers-0.9.3

- old
+ new

@@ -1,12 +1,14 @@
 module Eco
   module API
-    module UseCases
+    class UseCases
       class UseCaseChain < UseCase
         MAX_CHAINS   = 70
         @@num_chains = 0
 
+        @types  = [:import, :filter, :transform, :sync, :export]
+
         def initialize(name = nil, type: nil, root:, usecase: nil, &block)
           if usecase
             raise "Expected Eco::API::UseCases::UseCase. Given #{usecase.class}" if !usecase.is_a?(Eco::API::UseCases::UseCase)
             type = usecase.type
             name = usecase.name
@@ -17,11 +19,11 @@
           @chains   = []
           @resolved_chains = nil
         end
 
         def root=(value)
-          raise "You cannot change root UseGroup once the chains have been resolved" if @resolved_chains
+          raise "You cannot change root Eco::API::UseCases once the chains have been resolved" if @resolved_chains
           super(value)
         end
 
         def use(preserve_chains: false, recursive: false)
           UseCase.new(@name, type: @type, root: @root, &@case).tap do |newcase|
@@ -41,13 +43,19 @@
               end
             end
           end
         end
 
-        def launch(input: nil, people: nil, session:, options: {})
-          data_model = super(input: input, people: people, session: session, options: options)
-          launch_chain(data_model)
+        # @see Eco::API::UseCases::UseCase#launch
+        def launch(io: nil, **kargs)
+          super(io: io, **kargs).tap do |uio|
+            next if resolved_chains.empty?
+
+            resolved_chains.each do |usecase|
+              uio = usecase.launch(io: uio.chain(usecase: usecase))
+            end
+          end
         end
 
         def chain(usecase = nil)
           @@num_chains += 1
           raise "Reached maximum number of chained use cases (#{MAX_CHAINS}). Looks like a recursive cyclic chain 'use'" if @@num_chains >= MAX_CHAINS
@@ -65,35 +73,17 @@
           usecase.chain(self)
         end
 
         def resolved_chains(use_group = nil)
           return @resolved_chains if @resolved_chains
-          raise "Only UseGroup object can resolve chains. Given: #{use_group} " if use_group && !use_group.is_a?(UseGroup)
+          raise "Only Eco::API::UseCases object can contain resolved chains. Given: #{use_group.class} " if use_group && !use_group.is_a?(Eco::API::UseCases)
 
           use_group = use_group || @root
           @resolved_chains = @chains.map do |usecase|
             usecase = usecase.call(use_group)  if usecase.respond_to?(:call)
             raise "A UseCase can only be chained with another UseCase" if usecase && !usecase.is_a?(UseCase)
             usecase.resolved_chains(use_group) if usecase.respond_to?(:resolved_chains)
             usecase
-          end
-        end
-
-        private
-
-        def launch_chain(data_model)
-          return data_model if resolved_chains.empty?
-
-          data_model.tap do |dm|
-            dm[self][:chains] ||= {}
-
-            resolved_chains.each do |usecase|
-              # chained cases use same params as parent case (out of simplicity)
-              data_chain = dm[self][:io].chain(usecase: usecase)
-              keyed_data = data_chain.params(keyed: true)
-              keyed_data.delete(:usecase)
-              dm[self][:chains].merge(usecase.launch(keyed_data))
-            end
           end
         end
 
       end
 