trailblazer-activity 0.7.1 → 0.8.0

data/lib/trailblazer/activity/present.rb

@@ -1,7 +1,7 @@
 require "hirb"
 
 module Trailblazer
-  class Activity < Module
+  class Activity
 
     # Task < Array
     # [ input, ..., output ]
@@ -11,19 +11,23 @@ module Trailblazer
       module Present
         module_function
 
-        def call(stack, level=1, tree=[])
-          tree(stack.to_a, level, tree)
+        def default_renderer(stack:, level:, input:, name:, **)
+          [ level, %{#{name}} ]
         end
 
-        def tree(stack, level, tree)
-          tree_for(stack, level, tree)
+        def call(stack, level: 1, tree: [], renderer: method(:default_renderer), **options)
+          tree(stack.to_a, level, tree: tree, renderer: renderer, **options)
+        end
+
+        def tree(stack, level, tree: tree, **options)
+          tree_for(stack, level, options.merge(tree: tree))
 
           Hirb::Console.format_output(tree, class: :tree, type: :directory)
         end
 
-        def tree_for(stack, level, tree)
-          stack.each do |task| # always a Stack::Task[input, ..., output]
-            input, output, nested = input_output_nested_for_task(task)
+        def tree_for(stack, level, tree:, renderer: ,**options)
+          stack.each do |lvl| # always a Stack::Task[input, ..., output]
+            input, output, nested = Trace::Level.input_output_nested_for_level(lvl)
 
             task = input.task
 
@@ -32,45 +36,16 @@ module Trailblazer
             name = (node = graph.find { |node| node[:task] == task }) ? node[:id] : task
             name ||= task # FIXME: bullshit
 
-            tree << [ level, name ]
+            tree << renderer.(stack: stack, level: level, input: input, name: name, **options)
 
             if nested.any? # nesting
-              tree_for(nested, level + 1, tree)
+              tree_for(nested, level + 1, options.merge(tree: tree, renderer: renderer))
             end
 
             tree
           end
         end
 
-        # DISCUSS: alternatively, we can have Task<input: output: data: >
-        def input_output_nested_for_task(task)
-          input  = task[0]
-          output = task[-1]
-
-          output, nested = output.is_a?(Entity::Output) ? [output, task-[input, output]] : [nil, task[1..-1]]
-
-          return input, output, nested
-        end
-
-        def to_name(debug_item)
-          track = debug_item[2]
-          klass = track.class == Class ? track : track.class
-          color = color_map[klass]
-
-          return debug_item[0].to_s unless color
-          colorify(debug_item[0], color)
-        end
-
-        def to_options(debug_item)
-          debug_item[4]
-        end
-
-
-
-        def colorify(string, color)
-          "\e[#{color_table[color]}m#{string}\e[0m"
-        end
-
         def color_map
           {
             Trailblazer::Activity::Start => :blue,

data/lib/trailblazer/activity/schema.rb

@@ -0,0 +1,13 @@
+module Trailblazer
+  class Activity
+    NodeAttributes = Struct.new(:id, :outputs, :task, :data)
+
+    # Schema is primitive data structure + an invoker (usually coming from Activity etc)
+    class Schema < Struct.new(:circuit, :outputs, :nodes, :config)
+
+      # @!method to_h()
+      #   Returns a hash containing the schema's components.
+
+    end # Schema
+  end
+end

data/lib/trailblazer/activity/schema/implementation.rb

@@ -0,0 +1,10 @@
+class Trailblazer::Activity
+  class Schema
+    module Implementation
+      # Implementation structures
+      Task = Struct.new(:circuit_task, :outputs, :extensions)
+
+      def self.Task(task, outputs, extensions=[]); Task.new(task, outputs, extensions) end
+    end
+  end
+end

data/lib/trailblazer/activity/schema/intermediate.rb

@@ -0,0 +1,94 @@
+class Trailblazer::Activity
+  class Schema
+    # An {Intermediate} structure defines the *structure* of the circuit. It usually
+    # comes from a DSL or a visual editor.
+    class Intermediate < Struct.new(:wiring, :stop_task_ids, :start_task_ids)
+      TaskRef = Struct.new(:id, :data) # TODO: rename to NodeRef
+      Out     = Struct.new(:semantic, :target)
+
+      def self.TaskRef(id, data={}); TaskRef.new(id, data) end
+      def self.Out(*args);           Out.new(*args)        end
+
+      # Compiles a {Schema} instance from an {intermediate} structure and
+      # the {implementation} object references.
+      #
+      # Intermediate structure, Implementation, calls extensions, passes {}config # TODO
+      def self.call(intermediate, implementation)
+        config_default = {wrap_static: Hash.new(TaskWrap.initial_wrap_static)}.freeze # DISCUSS: this really doesn't have to be here, but works for now and we want it in 99%.
+
+        circuit = circuit(intermediate, implementation)
+        nodes   = node_attributes(intermediate, implementation)
+        outputs = outputs(intermediate.stop_task_ids, nodes)
+        config  = config(implementation, config: config_default)
+        schema  = Schema.new(circuit, outputs, nodes, config)
+      end
+
+      # From the intermediate "template" and the actual implementation, compile a {Circuit} instance.
+      def self.circuit(intermediate, implementation)
+        end_events = intermediate.stop_task_ids
+
+        wiring = Hash[
+          intermediate.wiring.collect do |task_ref, outs|
+            task = implementation.fetch(task_ref.id)
+
+            [
+              task.circuit_task,
+              end_events.include?(task_ref.id) ? {} : connections_for(outs, task.outputs, implementation)
+            ]
+          end
+        ]
+
+        Circuit.new(
+          wiring,
+          intermediate.stop_task_ids.collect { |id| implementation.fetch(id).circuit_task },
+          start_task: intermediate.start_task_ids.collect { |id| implementation.fetch(id).circuit_task }[0]
+        )
+      end
+
+      # Compute the connections for {circuit_task}.
+      def self.connections_for(outs, task_outputs, implementation)
+        Hash[
+          outs.collect { |required_out|
+            [
+              for_semantic(task_outputs, required_out.semantic).signal,
+              implementation.fetch(required_out.target).circuit_task
+            ]
+          }.compact
+        ]
+      end
+
+      def self.node_attributes(intermediate, implementation)
+        intermediate.wiring.collect do |task_ref, outputs| # id, Task{circuit_task, outputs}
+          task = implementation.fetch(task_ref.id)
+          data = task_ref[:data] # TODO: allow adding data from implementation.
+
+          NodeAttributes.new(task_ref.id, task.outputs, task.circuit_task, data)
+        end
+      end
+
+      # intermediate/implementation independent.
+      def self.outputs(stop_task_ids, nodes_attributes)
+        stop_task_ids.collect do |id|
+          # Grab the {outputs} of the stop nodes.
+          nodes_attributes.find { |node_attrs| id == node_attrs.id }.outputs
+        end.flatten(1)
+      end
+
+      # Invoke each task's extensions (usually coming from the DSL or some macro).
+      def self.config(implementation, config:)
+        implementation.each do |id, task|
+          task.extensions.each { |ext| config = ext.(config: config, id: id, task: task) } # DISCUSS: ext must return new {Config}.
+        end
+
+        config
+      end
+
+      private
+
+      # Apply to any array.
+      def self.for_semantic(outputs, semantic)
+        outputs.find { |out| out.semantic == semantic } or raise "`#{semantic}` not found"
+      end
+    end # Intermediate
+  end
+end

data/lib/trailblazer/activity/structures.rb

@@ -1,57 +1,57 @@
-  module Trailblazer
-    class Activity < Module
-      # Generic run-time structures that are built via the DSL.
+module Trailblazer
+  class Activity
+    # Generic run-time structures that are built via the DSL.
 
-      # Builds an {Activity::End} instance.
-      def self.End(semantic)
-        End.new(semantic: semantic)
-      end
-
-      # Any instance of subclass of End will halt the circuit's execution when hit.
+    # Builds an {Activity::End} instance.
+    def self.End(semantic)
+      End.new(semantic: semantic)
+    end
 
-      # An End event is a simple structure typically found as the last task invoked
-      # in an activity. The special behavior is that it
-      # a) maintains a semantic that is used to further connect that very event
-      # b) its `End#call` method returns the end instance itself as the signal.
-      class End
-        def initialize(semantic:, **options)
-          @options = options.merge(semantic: semantic)
-        end
+    # Any instance of subclass of End will halt the circuit's execution when hit.
 
-        def call(args, circuit_options)
-          return self, args, circuit_options
-        end
+    # An End event is a simple structure typically found as the last task invoked
+    # in an activity. The special behavior is that it
+    # a) maintains a semantic that is used to further connect that very event
+    # b) its `End#call` method returns the end instance itself as the signal.
+    class End
+      def initialize(semantic:, **options)
+        @options = options.merge(semantic: semantic)
+      end
 
-        def to_h
-          @options
-        end
+      def call(args, circuit_options)
+        return self, args, circuit_options
+      end
 
-        def to_s
-          %{#<#{self.class.name} #{@options.collect{ |k,v| "#{k}=#{v.inspect}" }.join(" ")}>}
-        end
+      def to_h
+        @options
+      end
 
-        alias_method :inspect, :to_s
+      def to_s
+        %{#<#{self.class.name} #{@options.collect{ |k,v| "#{k}=#{v.inspect}" }.join(" ")}>}
       end
 
-      class Start < End
-        def call(args, circuit_options)
-          return Activity::Right, args, circuit_options
-        end
+      alias_method :inspect, :to_s
+    end
+
+    class Start < End
+      def call(args, circuit_options)
+        return Activity::Right, args, circuit_options
       end
+    end
 
-      class Signal;         end
-      class Right < Signal; end
-      class Left  < Signal; end
+    class Signal;         end
+    class Right < Signal; end
+    class Left  < Signal; end
 
-      # signal:   actual signal emitted by the task
-      # color:    the mapping, where this signal will travel to. This can be e.g. Left=>:success. The polarization when building the graph.
-      #             "i am traveling towards :success because ::step said so!"
-      # semantic: the original "semantic" or role of the signal, such as :success. This usually comes from the activity hosting this output.
-      Output = Struct.new(:signal, :semantic)
+    # signal:   actual signal emitted by the task
+    # color:    the mapping, where this signal will travel to. This can be e.g. Left=>:success. The polarization when building the graph.
+    #             "i am traveling towards :success because ::step said so!"
+    # semantic: the original "semantic" or role of the signal, such as :success. This usually comes from the activity hosting this output.
+    Output = Struct.new(:signal, :semantic)
 
-      # Builds an {Activity::Output} instance.
-      def self.Output(signal, color)
-        Output.new(signal, color).freeze
-      end
+    # Builds an {Activity::Output} instance.
+    def self.Output(signal, semantic)
+      Output.new(signal, semantic).freeze
     end
   end
+end

data/lib/trailblazer/activity/task_wrap.rb

@@ -1,5 +1,5 @@
 module Trailblazer
-  class Activity < Module
+  class Activity
     #
     # Example with tracing:
     #
@@ -10,31 +10,44 @@ module Trailblazer
         #   |-- Trace.capture_return [optional]
         #   |-- Wrap::End
     module TaskWrap
-      # The actual activity that implements the taskWrap.
-      def self.initial_activity
-        Module.new do
-          extend Trailblazer::Activity::Path(
-            name:             "taskWrap",
-            normalizer_class: Magnetic::DefaultNormalizer,
-            plus_poles:       Magnetic::PlusPoles.initial( :success => Magnetic::Builder::Path.default_outputs[:success] ) # DefaultNormalizer doesn't give us default PlusPoles.
-          )
-
-          task TaskWrap.method(:call_task), id: "task_wrap.call_task" # ::call_task is defined in task_wrap/call_task.
-        end
-      end
+      module_function
 
       # Compute runtime arguments necessary to execute a taskWrap per task of the activity.
-      def self.invoke(activity, args, wrap_runtime: {}, **circuit_options)
+      def invoke(activity, args, wrap_runtime: {}, **circuit_options)
         circuit_options = circuit_options.merge(
           runner:       TaskWrap::Runner,
           wrap_runtime: wrap_runtime,
-
-          activity: { adds: [], circuit: {} }, # for Runner
+          activity:     {wrap_static: {activity => initial_wrap_static}, nodes: {}}, # for Runner. Ideally we'd have a list of all static_wraps here (even nested).
         )
 
         # signal, (ctx, flow), circuit_options =
         Runner.(activity, args, circuit_options)
       end
+
+      # {:extension} API
+      # Extend the static taskWrap from a macro or DSL call.
+      # Gets executed in {Intermediate.call} which also provides {config}.
+
+      def initial_wrap_static(*)
+        initial_sequence = TaskWrap::Pipeline.new([["task_wrap.call_task", TaskWrap.method(:call_task)]])
+      end
+
+      # Use this in your macros if you want to extend the {taskWrap}.
+      def Extension(merge:)
+        Extension.new(merge: Pipeline::Merge.new(*merge))
+      end
+
+      class Extension
+        def initialize(merge:)
+          @merge = merge
+        end
+
+        def call(config:, task:, **)
+          before_pipe = State::Config.get(config, :wrap_static, task.circuit_task)
+
+          State::Config.set(config, :wrap_static, task.circuit_task, @merge.(before_pipe))
+        end
+      end
     end # TaskWrap
   end
 end

data/lib/trailblazer/activity/task_wrap/call_task.rb

@@ -1,10 +1,10 @@
-class Trailblazer::Activity < Module
+class Trailblazer::Activity
   module TaskWrap
     # TaskWrap step that calls the actual wrapped task and passes all `original_args` to it.
     #
     # It writes to wrap_ctx[:return_signal], wrap_ctx[:return_args]
-    def self.call_task((wrap_ctx, original_args), **circuit_options)
-      task  = wrap_ctx[:task]
+    def self.call_task(wrap_ctx, original_args)
+      task = wrap_ctx[:task]
 
       # Call the actual task we're wrapping here.
       # puts "~~~~wrap.call: #{task}"
@@ -13,7 +13,7 @@ class Trailblazer::Activity < Module
       # DISCUSS: do we want original_args here to be passed on, or the "effective" return_args which are different to original_args now?
       wrap_ctx = wrap_ctx.merge( return_signal: return_signal, return_args: return_args )
 
-      return Right, [ wrap_ctx, original_args ]
+      return wrap_ctx, original_args
     end
   end # Wrap
 end

data/lib/trailblazer/activity/task_wrap/inject.rb

@@ -0,0 +1,37 @@
+class Trailblazer::Activity
+  module TaskWrap
+    # Allows to inject attributes for a task and defaults them if not.
+    # Per default, the defaulting is scoped, meaning only the task will see it.
+    module Inject
+      module Defaults
+        module_function
+
+        def Extension(defaults)
+          # Returns new ctx.
+          input  = ->(original_ctx) do
+            defaulted_options = defaults_for(defaults, original_ctx)
+
+            Trailblazer.Context(original_ctx.merge(defaulted_options))
+          end
+
+          output = ->(original_ctx, new_ctx) { # FIXME: use Unscope
+            _, mutable_data = new_ctx.decompose
+
+            # we are only interested in the {mutable_data} part since the disposed part
+            # represents the injected/defaulted data.
+            original_ctx.merge(mutable_data)
+          }
+
+          VariableMapping::Extension(input, output, id: input)
+        end
+
+        # go through all defaultable options and default them if appropriate.
+        def defaults_for(defaults, original_ctx)
+          Hash[
+            defaults.collect { |k, v| [k, original_ctx[k] || v] } # FIXME: doesn't allow {false/nil} currently.
+          ]
+        end
+      end
+    end # Inject
+  end
+end

data/lib/trailblazer/activity/task_wrap/pipeline.rb

@@ -0,0 +1,55 @@
+class Trailblazer::Activity
+  module TaskWrap
+    # This "circuit" is optimized for
+    #   a) merging speed at run-time, since features like tracing will be applied here.
+    #   b) execution speed. Every task in the real circuit is wrapped with one of us.
+    class Pipeline
+      def initialize(sequence)
+        @sequence = sequence # [[id, task], ..]
+      end
+
+      def call(wrap_ctx, original_args)
+        @sequence.each { |(id, task)| wrap_ctx, original_args = task.(wrap_ctx, original_args) }
+
+        return wrap_ctx, original_args
+      end
+
+      attr_reader :sequence
+
+      def self.insert_before(pipe, before_id, insertion)
+        index = pipe.sequence.find_index { |(id, _)| id == before_id }
+
+        seq = pipe.sequence.dup
+
+        Pipeline.new(seq.insert(index, insertion))
+      end
+
+      def self.insert_after(pipe, after_id, insertion)
+        index = pipe.sequence.find_index { |(id, _)| id == after_id }
+
+        seq = pipe.sequence.dup
+
+        Pipeline.new(seq.insert(index+1, insertion))
+      end
+
+      def self.append(pipe, _, insertion) # TODO: test me.
+        Pipeline.new(pipe.sequence + [insertion])
+      end
+
+      # Merges {extension_rows} into the {task_wrap_pipeline}.
+      # This is usually used in step extensions or at runtime for {wrap_runtime}.
+      #
+      # {Extension} API
+      class Merge # TODO: RENAME TO TaskWrap::Extension(::Merge)
+        def initialize(*extension_rows)
+          @extension_rows = extension_rows
+        end
+
+        def call(task_wrap_pipeline)
+          @extension_rows.collect { |(insert_function, target_id, row)| task_wrap_pipeline = insert_function.(task_wrap_pipeline, target_id, row) }
+          task_wrap_pipeline
+        end
+      end
+    end
+  end
+end