trailblazer-activity 0.2.1 → 0.3.0

data/lib/trailblazer/activity/process.rb

@@ -0,0 +1,16 @@
+module Trailblazer
+  class Activity::Process
+    # The executable run-time instance for an Activity.
+    def initialize(circuit_hash, end_events)
+      @default_start_event = circuit_hash.keys.first
+      @circuit             = Circuit.new(circuit_hash, end_events)
+    end
+
+    def call(args, task: @default_start_event, **circuit_options)
+      @circuit.(
+        args,
+        circuit_options.merge( task: task ) , # this passes :runner to the {Circuit}.
+      )
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+module Trailblazer
+  module Activity::Schema
+    # Helps organizing the structure of the circuit and allows to define steps that
+    # might be inserted in a completely different order, but it's experimental.
+    #
+    # Translates linear DSL calls that might refer to the same task several times into a linear "drawing instruction"
+    # that can be consumed by Schema.bla.
+    #
+    # This class is experimental.
+    class Dependencies
+      def initialize
+        @groups  = {
+          start:      Sequence.new,
+          main:       Sequence.new, # normal steps
+          end:        Sequence.new, # ends
+          unresolved: Sequence.new, # div
+        }
+
+        @order = [ :start, :main, :end, :unresolved ]
+      end
+
+      def add(id, seq_options, group: :main, **sequence_options)
+        group = @groups[group] or raise "unknown group #{group}, implement me"
+
+        group.add(id, seq_options, **sequence_options) # handles
+      end
+
+      def to_a
+        @order.collect{ |name| @groups[name].to_a }.flatten(1)
+      end
+
+      # private
+      def find(id)
+        @groups.find do |name, group|
+          index = group.send( :find_index, id )
+          return group, index if index
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+module Trailblazer
+  module Activity::Schema
+    #  the list of what tasks to add to the graph, for the "drawer"
+    # produces immutable list of: (node, magnetic_to (incoming colors), outgoing colors)
+    #  via #to_a
+
+    #mutable, for DSL
+    #
+    # @api private
+    class Sequence < ::Array
+      Element = Struct.new(:id, :configuration)
+
+      # Insert the task into {Sequence} array by respecting options such as `:before`.
+      # This mutates the object per design.
+      #
+      # @param wiring [ [:success, :special_1], A, [ Output, Output ] ]
+      def add(id, wiring, before:nil, after:nil, replace:nil, delete:nil)
+        element = Element.new(id, wiring).freeze
+
+        return insert(find_index!(before),  element) if before
+        return insert(find_index!(after)+1, element) if after
+        return self[find_index!(replace)] = element  if replace
+        return delete_at(find_index!(delete))        if delete
+
+        self << element
+      end
+
+      def to_a
+        collect { |element| element.configuration }
+      end
+
+      private
+
+      def find_index(id)
+        element = find { |el| el.id == id }
+        index(element)
+      end
+
+      def find_index!(id)
+        find_index(id) or raise IndexError.new(id)
+      end
+
+      class IndexError < IndexError; end
+    end
+  end
+end

data/lib/trailblazer/activity/structures.rb

@@ -0,0 +1,41 @@
+  module Trailblazer
+    class Activity
+      # End event is just another callable task.
+      # Any instance of subclass of End will halt the circuit's execution when hit.
+      class End
+        def initialize(name, options={})
+          @name    = name
+          @options = options
+        end
+
+        def call(*args)
+          [ self, *args ]
+        end
+      end
+
+      class Start < End
+        def call(*args)
+          return Activity::Right, *args
+        end
+      end
+
+      # Builder for Activity::End.
+      def self.End(name, semantic=name)
+        Activity::End.new(name, semantic: semantic)
+      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)
+
+      def self.Output(signal, color)
+        Output.new(signal, color).freeze
+      end
+    end
+  end

data/lib/trailblazer/activity/subprocess.rb

@@ -9,6 +9,8 @@ module Trailblazer
     # Subprocess allows to have tasks with a different call interface and start event.
     # @param activity any object with an {Activity interface}
     class Subprocess
+      include Interface
+
       def initialize(activity, call: :call, **options)
         @activity = activity
         @options = options
@@ -20,7 +22,13 @@ module Trailblazer
       end
 
       # @private
-      attr_reader :activity # we actually only need this for introspection.
+      def decompose
+        @activity.decompose # TODO: test explicitly
+      end
+
+      def debug
+        @activity.debug
+      end
     end
   end
 end

data/lib/trailblazer/activity/trace.rb

@@ -10,43 +10,52 @@ module Trailblazer
     module Trace
       def self.call(activity, (options), *args, &block)
         tracing_flow_options = {
-          stack:        Trace::Stack.new,
-          # Note that we don't pass :wrap_static here, that's handled by Task.__call__.
-          introspection:        {}, # usually set that in Activity::call.
+          stack:         Trace::Stack.new,
         }
 
         tracing_circuit_options = {
-          runner:       Wrap::Runner,
-          wrap_runtime: ::Hash.new(Trace.wirings), # FIXME: this still overrides existing wrap_runtimes.
-          wrap_static:  ::Hash.new( Trailblazer::Activity::Wrap.initial_activity ) # FIXME
+          runner:        Wrap::Runner,
+          wrap_runtime:  ::Hash.new(Trace.wirings), # FIXME: this still overrides existing wrap_runtimes.
+          wrap_static:   ::Hash.new( Trailblazer::Activity::Wrap.initial_activity ), # FIXME
+          introspection: compute_debug(activity), # FIXME: this is still also set in Activity::call
         }
 
-        last_signal, (options, flow_options) = call_circuit( activity, [
-          options,
+        last_signal, (options, flow_options) = call_activity( activity, [ options, tracing_flow_options ], tracing_circuit_options, &block )
           # tracing_flow_options.merge(flow_options),
-          tracing_flow_options,
-        ], tracing_circuit_options, &block )
 
         return flow_options[:stack].to_a, last_signal, options, flow_options
       end
 
+      private
+
       # TODO: test alterations with any wrap_circuit.
-      def self.call_circuit(activity, *args, &block)
+      def self.call_activity(activity, *args, &block)
         return activity.(*args) unless block
         block.(activity, *args)
       end
 
-      # Graph insertions for the trace tasks that capture the arguments just before calling the task,
+      # TODO: this is experimental.
+      # Go through all nested Activities and grab their `Activity.debug` field. This gets all merged into
+      # one big debugging hash, instead of computing it overly complex at runtime and while executing the circuit.
+      def self.compute_debug(activity)
+        arrs = Introspect.collect( activity, recursive: true ) { |task, _| task }.find_all { |task| task.is_a?(Interface) }.collect { |task| task.debug }.flatten(1).compact
+
+        arrs.inject( activity.debug ) { |memo, debug| memo.merge(debug) }
+      end
+
+      # Insertions for the trace tasks that capture the arguments just before calling the task,
       # and before the TaskWrap is finished.
       #
       # Note that the TaskWrap steps are implemented in Activity::Wrap::Trace.
       def self.wirings
-        [
-          [ :insert_before!, "task_wrap.call_task", node: [ Wrap::Trace.method(:capture_args),   id: "task_wrap.capture_args" ], outgoing: [ Circuit::Right, {} ], incoming: ->(*) { true } ],
-          [ :insert_before!, "End.default",         node: [ Wrap::Trace.method(:capture_return), id: "task_wrap.capture_return" ], outgoing: [ Circuit::Right, {} ], incoming: ->(*) { true } ],
-        ]
+        Activity::Magnetic::Builder::Path.plan do
+          task Wrap::Trace.method(:capture_args),   id: "task_wrap.capture_args",   before: "task_wrap.call_task"
+          task Wrap::Trace.method(:capture_return), id: "task_wrap.capture_return", before: "End.success", group: :end
+        end
       end
 
+      Entity = Struct.new(:task, :type, :value, :value2, :introspection)
+
       # Mutable/stateful per design. We want a (global) stack!
       class Stack
         def initialize

data/lib/trailblazer/activity/version.rb

@@ -1,5 +1,5 @@
 module Trailblazer
   class Activity
-    VERSION = "0.2.1"
+    VERSION = "0.3.0"
   end
 end

data/lib/trailblazer/activity/wrap.rb

@@ -12,20 +12,11 @@ class Trailblazer::Activity
         #   |-- Trace.capture_return [optional]
         #   |-- Wrap::End
 
-    # Activity = Trailblazer::Activity::Activity({ id: "task.wrap" }, end: { default: End.new(:default) }) do |act|
-    #   {
-    #     act[:Start] => { Right => Call }, # see Wrap::call_task
-    #     Call        => { Right => act[:End] },
-    #   }
-    # end # Activity
-
     def self.initial_activity
-      Trailblazer::Activity.from_wirings(
-        [
-          [ :attach!, target: [ Trailblazer::Circuit::End.new(:default), type: :event, id: "End.default" ], edge: [ Trailblazer::Circuit::Right, {} ] ],
-          [ :insert_before!, "End.default", node: [ Wrap.method(:call_task), id: "task_wrap.call_task" ], outgoing: [ Trailblazer::Circuit::Right, {} ], incoming: ->(*) { true } ]
-        ]
-      )
+      Magnetic::Builder::Path.plan do
+        # Wrap.call_task is defined in wrap/call_task.
+        task Wrap.method(:call_task), id: "task_wrap.call_task"
+      end
     end
   end
 end

data/lib/trailblazer/circuit.rb

@@ -6,17 +6,15 @@ module Trailblazer
   #
   # @param map         [Hash] Defines the wiring.
   # @param stop_events [Array] Tasks that stop execution of the circuit.
-  # @param name        [Hash] Names for tracing, debugging and exceptions. `:id` is a reserved key for circuit name.
   #
   #   result = circuit.(start_at, *args)
   #
   # @see Activity
   # @api semi-private
   class Circuit
-    def initialize(map, stop_events, name)
+    def initialize(map, stop_events)
       @map         = map
       @stop_events = stop_events
-      @name        = name
     end
 
     # @param args [Array] all arguments to be passed to the task's `call`
@@ -46,16 +44,15 @@ module Trailblazer
         return [ last_signal, args ] if @stop_events.include?(task) # DISCUSS: return circuit_options here?
 
         task = next_for(task, last_signal) do |next_task, in_map|
-          task_name = @name[task] || task # TODO: this must be implemented only once, somewhere.
-          raise IllegalInputError.new("#{@name[:id]} #{task_name}") unless in_map
-          raise IllegalOutputSignalError.new("from #{@name[:id]}: `#{task_name}`===>[ #{last_signal.inspect} ]") unless next_task
+          raise IllegalInputError.new("#{task}") unless in_map
+          raise IllegalOutputSignalError.new("from : `#{task}`===>[ #{last_signal.inspect} ]") unless next_task
         end
       end
     end
 
     # Returns the circuit's components.
     def to_fields
-      [ @map, @stop_events, @name]
+      [ @map, @stop_events ]
     end
 
   private
@@ -76,33 +73,5 @@ module Trailblazer
 
     class IllegalOutputSignalError < RuntimeError
     end
-
-    # End event is just another callable task.
-    # Any instance of subclass of End will halt the circuit's execution when hit.
-    class End
-      def initialize(name, options={})
-        @name    = name
-        @options = options
-      end
-
-      def call(*args)
-        [ self, *args ]
-      end
-    end
-
-    class Start < End
-      def call(*args)
-        [ Right, *args ]
-      end
-    end
-
-    # Builder for Circuit::End when defining the Activity's circuit.
-    def self.End(name, options={})
-      End.new(name, options)
-    end
-
-    class Signal;         end
-		class Right < Signal; end
-    class Left  < Signal; end
   end
 end

data/lib/trailblazer/wrap/call_task.rb

@@ -7,13 +7,13 @@ class Trailblazer::Activity
       task  = wrap_ctx[:task]
 
       # Call the actual task we're wrapping here.
-      puts "~~~~wrap.call: #{task}"
+      # puts "~~~~wrap.call: #{task}"
       result_direction, result_args = task.( *original_args ) # we lose :exec_context here.
 
       # DISCUSS: do we want original_args here to be passed on, or the "effective" result_args which are different to original_args now?
       wrap_ctx = wrap_ctx.merge( result_direction: result_direction, result_args: result_args )
 
-      [ Trailblazer::Circuit::Right, [ wrap_ctx, original_args ], **circuit_options ]
+      [ Right, [ wrap_ctx, original_args ], **circuit_options ]
     end
   end # Wrap
 end

data/lib/trailblazer/wrap/runner.rb

@@ -41,7 +41,13 @@ class Trailblazer::Activity
 
         # Apply runtime alterations.
         # Grab the additional wirings for the particular `task` from `wrap_runtime` (returns default otherwise).
-        wrap_activity = Trailblazer::Activity.merge(wrap_activity, wrap_runtime[task])
+
+        # NOTE: the recompilation is absolutely not necessary at runtime and could be avoided if the runtime wrap is empty.
+        # TODO: make this faster.
+        adds = Trailblazer::Activity::Magnetic::Builder.merge(wrap_activity, wrap_runtime[task])
+        wrap_activity, outputs = Magnetic::Builder::Finalizer.(adds)
+
+        wrap_activity
       end
     end # Runner
   end

data/lib/trailblazer/wrap/trace.rb

@@ -1,26 +1,27 @@
 class Trailblazer::Activity
   module Wrap
+    # TaskWrap tasks for tracing.
     module Trace
       # def self.capture_args(direction, options, flow_options, wrap_config, original_flow_options)
       def self.capture_args((wrap_config, original_args), **circuit_options)
-        (original_options, original_flow_options, _) = original_args[0]
+        (original_options, original_flow_options), original_circuit_options = original_args
 
         original_flow_options[:stack].indent!
 
-        original_flow_options[:stack] << [ wrap_config[:task], :args, nil, {}, original_flow_options[:introspection] ]
+        original_flow_options[:stack] << Trailblazer::Activity::Trace::Entity.new( wrap_config[:task], :args, nil, {}, original_circuit_options[:introspection] )
 
-        [ Trailblazer::Circuit::Right, [wrap_config, original_args], **circuit_options ]
+        [ Trailblazer::Activity::Right, [wrap_config, original_args], **circuit_options ]
       end
 
       def self.capture_return((wrap_config, original_args), **circuit_options)
         (original_options, original_flow_options, _) = original_args[0]
 
-        original_flow_options[:stack] << [ wrap_config[:task], :return, wrap_config[:result_direction], {} ]
+        original_flow_options[:stack] << Trailblazer::Activity::Trace::Entity.new(  wrap_config[:task], :return, wrap_config[:result_direction], {} )
 
         original_flow_options[:stack].unindent!
 
 
-        [ Trailblazer::Circuit::Right, [wrap_config, original_args], **circuit_options ]
+        [ Trailblazer::Activity::Right, [wrap_config, original_args], **circuit_options ]
       end
     end
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: trailblazer-activity
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.3.0
 platform: ruby
 authors:
 - Nick Sutterer
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-10-21 00:00:00.000000000 Z
+date: 2017-12-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: hirb
@@ -93,26 +93,37 @@ files:
 - CHANGES.md
 - Gemfile
 - NOTES
+- NOTES_
 - README.md
 - Rakefile
 - lib/trailblazer-activity.rb
 - lib/trailblazer/activity.rb
-- lib/trailblazer/activity/graph.rb
+- lib/trailblazer/activity/heritage.rb
+- lib/trailblazer/activity/introspection.rb
+- lib/trailblazer/activity/magnetic.rb
+- lib/trailblazer/activity/magnetic/builder.rb
+- lib/trailblazer/activity/magnetic/builder/block.rb
+- lib/trailblazer/activity/magnetic/builder/fast_track.rb
+- lib/trailblazer/activity/magnetic/builder/path.rb
+- lib/trailblazer/activity/magnetic/builder/railway.rb
+- lib/trailblazer/activity/magnetic/dsl.rb
+- lib/trailblazer/activity/magnetic/dsl/alterations.rb
+- lib/trailblazer/activity/magnetic/dsl/plus_poles.rb
+- lib/trailblazer/activity/magnetic/finalizer.rb
+- lib/trailblazer/activity/magnetic/generate.rb
 - lib/trailblazer/activity/present.rb
+- lib/trailblazer/activity/process.rb
+- lib/trailblazer/activity/schema/dependencies.rb
+- lib/trailblazer/activity/schema/sequence.rb
+- lib/trailblazer/activity/structures.rb
 - lib/trailblazer/activity/subprocess.rb
 - lib/trailblazer/activity/trace.rb
 - lib/trailblazer/activity/version.rb
 - lib/trailblazer/activity/wrap.rb
 - lib/trailblazer/circuit.rb
-- lib/trailblazer/circuit/testing.rb
-- lib/trailblazer/container_chain.rb
-- lib/trailblazer/context.rb
-- lib/trailblazer/option.rb
 - lib/trailblazer/wrap/call_task.rb
-- lib/trailblazer/wrap/inject.rb
 - lib/trailblazer/wrap/runner.rb
 - lib/trailblazer/wrap/trace.rb
-- lib/trailblazer/wrap/variable_mapping.rb
 - trailblazer-activity.gemspec
 homepage: http://trailblazer.to/gems/workflow
 licenses:
@@ -134,7 +145,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.8
+rubygems_version: 2.6.12
 signing_key: 
 specification_version: 4
 summary: The main element for Trailblazer's BPMN-compliant workflows.