trailblazer-activity 0.3.2 → 0.4.o

data/lib/trailblazer/{wrap → activity/task_wrap}/call_task.rb

@@ -1,5 +1,5 @@
-class Trailblazer::Activity
-  module Wrap
+class Trailblazer::Activity < Module
+  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]
@@ -13,7 +13,7 @@ class Trailblazer::Activity
       # 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 )
 
-      [ Right, [ wrap_ctx, original_args ], **circuit_options ]
+      return Right, [ wrap_ctx, original_args ]
     end
   end # Wrap
 end

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

@@ -0,0 +1,23 @@
+module Trailblazer
+  module Activity::TaskWrap
+    # This is instantiated via the DSL, and passed to the :extension API,
+    # allowing to add steps to the Activity's static_wrap.
+    # Compile-time function
+    class Merge
+      def initialize(extension_plan)
+        @extension_plan = extension_plan
+      end
+
+      # {:extension API}
+      def call(activity, task, local_options, *returned_options)
+        # we could make the default initial_activity injectable via the DSL, the value would sit in returned_options or local_options.
+        static_wrap = Activity::TaskWrap.wrap_static_for(task, wrap_static: activity[:wrap_static] || {})
+
+        # # macro might want to apply changes to the static task_wrap (e.g. Inject)
+        new_wrap =  Activity::Path::Plan.merge( static_wrap, @extension_plan )
+
+        activity[:wrap_static, task] = new_wrap
+      end
+    end
+  end
+end

data/lib/trailblazer/{wrap → activity/task_wrap}/runner.rb

@@ -1,5 +1,5 @@
-class Trailblazer::Activity
-  module Wrap
+class Trailblazer::Activity < Module
+  module TaskWrap
     # The runner is passed into Activity#call( runner: Runner ) and is called for every task in the circuit.
     # It runs the TaskWrap per task.
     #
@@ -9,16 +9,15 @@ class Trailblazer::Activity
       #
       # @api private
       # @interface Runner
-      def self.call(task, args, wrap_runtime: raise, wrap_static: raise, **circuit_options)
+      def self.call(task, args, **circuit_options)
         wrap_ctx = { task: task }
 
         # this activity is "wrapped around" the actual `task`.
-        task_wrap_activity = apply_wirings(task, wrap_static, wrap_runtime)
+        task_wrap_activity = merge_static_with_runtime(task, circuit_options)
 
         # We save all original args passed into this Runner.call, because we want to return them later after this wrap
         # is finished.
-        original_args = [ args, circuit_options.merge( wrap_runtime: wrap_runtime, wrap_static: wrap_static ) ]
-
+        original_args = [ args, circuit_options ]
         # call the wrap {Activity} around the task.
         wrap_end_signal, ( wrap_ctx, _ ) = task_wrap_activity.(
           [ wrap_ctx, original_args ] # we omit circuit_options here on purpose, so the wrapping activity uses the default, plain Runner.
@@ -27,7 +26,7 @@ class Trailblazer::Activity
         # don't return the wrap's end signal, but the one from call_task.
         # return all original_args for the next "real" task in the circuit (this includes circuit_options).
 
-        [ wrap_ctx[:return_signal], wrap_ctx[:return_args] ]
+        return wrap_ctx[:return_signal], wrap_ctx[:return_args]
       end
 
       private
@@ -36,19 +35,18 @@ class Trailblazer::Activity
       #
       # NOTE: this is for performance reasons: we could have only one hash containing everything but that'd mean
       # unnecessary computations at `call`-time since steps might not even be executed.
-      def self.apply_wirings(task, wrap_static, wrap_runtime)
-        wrap_activity = wrap_static[task]   # find static wrap for this specific task, or default wrap activity.
+      # TODO: make this faster.
+      def self.merge_static_with_runtime(task, wrap_runtime:, **circuit_options)
+        wrap_activity = TaskWrap.wrap_static_for(task, circuit_options)  # find static wrap for this specific task, or default wrap activity.
 
         # Apply runtime alterations.
         # Grab the additional wirings for the particular `task` from `wrap_runtime` (returns default otherwise).
-
-        # 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
+        wrap_runtime[task] ? Trailblazer::Activity::Path::Plan.merge(wrap_activity, wrap_runtime[task]) : wrap_activity
       end
     end # Runner
+
+    def self.wrap_static_for(task, wrap_static:, default_activity: TaskWrap.initial_activity, **)
+      wrap_static[task] || default_activity
+    end
   end
 end

data/lib/trailblazer/{wrap → activity/task_wrap}/trace.rb

@@ -1,5 +1,5 @@
-class Trailblazer::Activity
-  module Wrap
+class Trailblazer::Activity < Module
+  module TaskWrap
     # TaskWrap tasks for tracing.
     module Trace
       # def self.capture_args(direction, options, flow_options, wrap_config, original_flow_options)
@@ -8,7 +8,7 @@ class Trailblazer::Activity
 
         original_flow_options[:stack].indent!
 
-        original_flow_options[:stack] << Trailblazer::Activity::Trace::Entity.new( wrap_config[:task], :args, nil, {}, original_circuit_options[:introspection] )
+        original_flow_options[:stack] << Trailblazer::Activity::Trace::Entity.new( wrap_config[:task], :args, nil, {}, original_circuit_options[:introspect] )
 
         [ Trailblazer::Activity::Right, [wrap_config, original_args], **circuit_options ]
       end

data/lib/trailblazer/activity/trace.rb

@@ -1,6 +1,5 @@
 module Trailblazer
-  class Activity
-    # Trace#call will call the activities and trace what steps are called, options passed,
+  class Activity < Module   # Trace#call will call the activities and trace what steps are called, options passed,
     # and the order and nesting.
     #
     #   stack, _ = Trailblazer::Activity::Trace.(activity, activity[:Start], { id: 1 })
@@ -8,49 +7,44 @@ module Trailblazer
     #
     # Hooks into the TaskWrap.
     module Trace
-      def self.call(activity, (options), *args, &block)
+      # {:argumenter} API
+      # FIXME: needs Introspect.arguments_for_call
+      # FIXME: needs TaskWrap.arguments_for_call
+      def self.arguments_for_call(activity, (options, flow_options), **circuit_options)
         tracing_flow_options = {
           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
-          introspection: compute_debug(activity), # FIXME: this is still also set in Activity::call
+          wrap_runtime:  ::Hash.new(Trace.wirings), # FIXME: this still overrides existing :wrap_runtime.
         }
 
-        last_signal, (options, flow_options) = call_activity( activity, [ options, tracing_flow_options ], tracing_circuit_options, &block )
-          # tracing_flow_options.merge(flow_options),
-
-        return flow_options[:stack].to_a, last_signal, options, flow_options
+        return activity, [ options, flow_options.merge(tracing_flow_options) ], circuit_options.merge(tracing_circuit_options)
       end
 
-      private
+      def self.call(activity, (options, flow_options), *args)
+        activity, (options, flow_options), circuit_options = Trace.arguments_for_call( activity, [options, flow_options], {} ) # only run once for the entire circuit!
+        last_signal, (options, flow_options) =
+          activity.(
+            [options, flow_options],
+            circuit_options.merge({ argumenter: [ Introspect.method(:arguments_for_call), TaskWrap.method(:arguments_for_call) ] })
+          )
 
-      # TODO: test alterations with any wrap_circuit.
-      def self.call_activity(activity, *args, &block)
-        return activity.(*args) unless block
-        block.(activity, *args)
+        return flow_options[:stack].to_a, last_signal, [options, flow_options]
       end
 
-      # 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
+      private
 
       # 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.
+      # Note that the TaskWrap steps are implemented in Activity::TaskWrap::Trace.
       def self.wirings
-        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
+        Module.new do
+          extend Activity::Path::Plan()
+
+          task TaskWrap::Trace.method(:capture_args),   id: "task_wrap.capture_args",   before: "task_wrap.call_task"
+          task TaskWrap::Trace.method(:capture_return), id: "task_wrap.capture_return", before: "End.success", group: :end
         end
       end
 

data/lib/trailblazer/activity/version.rb

@@ -1,5 +1,5 @@
 module Trailblazer
-  class Activity
-    VERSION = "0.3.2"
+  class Activity < Module
+    VERSION = "0.4.o"
   end
 end

data/lib/trailblazer/circuit.rb

@@ -12,9 +12,11 @@ module Trailblazer
   # @see Activity
   # @api semi-private
   class Circuit
-    def initialize(map, stop_events)
+    def initialize(map, stop_events, name: nil, start_task: map.keys.first)
       @map         = map
       @stop_events = stop_events
+      @name        = name
+      @start_task  = start_task
     end
 
     # @param args [Array] all arguments to be passed to the task's `call`
@@ -32,7 +34,7 @@ module Trailblazer
     # @return [last_signal, options, flow_options, *args]
     #
     # DISCUSS: returned circuit_options are ignored when calling the runner.
-    def call(args, task: raise, runner: Run, **circuit_options)
+    def call(args, task: @start_task, runner: Run, **circuit_options)
       loop do
         last_signal, args, _ignored_circuit_options = runner.(
           task,
@@ -45,14 +47,14 @@ module Trailblazer
 
         task = next_for(task, last_signal) do |next_task, in_map|
           raise IllegalInputError.new("#{task}") unless in_map
-          raise IllegalOutputSignalError.new("from : `#{task}`===>[ #{last_signal.inspect} ]") unless next_task
+          raise IllegalOutputSignalError.new("#{@name}[#{task}][ #{last_signal.inspect} ]") unless next_task
         end
       end
     end
 
     # Returns the circuit's components.
-    def to_fields
-      [ @map, @stop_events ]
+    def decompose
+      return @map, @stop_events
     end
 
   private

data/trailblazer-activity.gemspec

@@ -21,11 +21,12 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
 
   spec.add_dependency "hirb"
+  spec.add_dependency "trailblazer-context"
 
   spec.add_development_dependency "bundler", "~> 1.14"
   spec.add_development_dependency "rake", "~> 10.0"
   spec.add_development_dependency "minitest", "~> 5.0"
   spec.add_development_dependency "trailblazer-test"
 
-  spec.required_ruby_version = '>= 2.0.0'
+  spec.required_ruby_version = '>= 2.1.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: trailblazer-activity
 version: !ruby/object:Gem::Version
-  version: 0.3.2
+  version: 0.4.o
 platform: ruby
 authors:
 - Nick Sutterer
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-12-23 00:00:00.000000000 Z
+date: 2018-01-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: hirb
@@ -24,6 +24,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: trailblazer-context
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -100,12 +114,20 @@ files:
 - Rakefile
 - lib/trailblazer-activity.rb
 - lib/trailblazer/activity.rb
-- lib/trailblazer/activity/heritage.rb
-- lib/trailblazer/activity/introspection.rb
+- lib/trailblazer/activity/config.rb
+- lib/trailblazer/activity/dsl/add_task.rb
+- lib/trailblazer/activity/dsl/helper.rb
+- lib/trailblazer/activity/implementation/build_state.rb
+- lib/trailblazer/activity/implementation/fast_track.rb
+- lib/trailblazer/activity/implementation/interface.rb
+- lib/trailblazer/activity/implementation/path.rb
+- lib/trailblazer/activity/implementation/railway.rb
+- lib/trailblazer/activity/introspect.rb
 - lib/trailblazer/activity/magnetic.rb
 - lib/trailblazer/activity/magnetic/builder.rb
-- lib/trailblazer/activity/magnetic/builder/block.rb
+- lib/trailblazer/activity/magnetic/builder/default_normalizer.rb
 - lib/trailblazer/activity/magnetic/builder/fast_track.rb
+- lib/trailblazer/activity/magnetic/builder/normalizer.rb
 - lib/trailblazer/activity/magnetic/builder/path.rb
 - lib/trailblazer/activity/magnetic/builder/railway.rb
 - lib/trailblazer/activity/magnetic/dsl.rb
@@ -113,19 +135,22 @@ files:
 - lib/trailblazer/activity/magnetic/dsl/plus_poles.rb
 - lib/trailblazer/activity/magnetic/finalizer.rb
 - lib/trailblazer/activity/magnetic/generate.rb
+- lib/trailblazer/activity/magnetic/merge.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/state.rb
 - lib/trailblazer/activity/structures.rb
 - lib/trailblazer/activity/subprocess.rb
+- lib/trailblazer/activity/task_builder.rb
+- lib/trailblazer/activity/task_wrap.rb
+- lib/trailblazer/activity/task_wrap/call_task.rb
+- lib/trailblazer/activity/task_wrap/merge.rb
+- lib/trailblazer/activity/task_wrap/runner.rb
+- lib/trailblazer/activity/task_wrap/trace.rb
 - lib/trailblazer/activity/trace.rb
 - lib/trailblazer/activity/version.rb
-- lib/trailblazer/activity/wrap.rb
 - lib/trailblazer/circuit.rb
-- lib/trailblazer/wrap/call_task.rb
-- lib/trailblazer/wrap/runner.rb
-- lib/trailblazer/wrap/trace.rb
 - trailblazer-activity.gemspec
 homepage: http://trailblazer.to/gems/workflow
 licenses:
@@ -139,15 +164,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.0.0
+      version: 2.1.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.8
+rubygems_version: 2.7.3
 signing_key: 
 specification_version: 4
 summary: The main element for Trailblazer's BPMN-compliant workflows.

data/lib/trailblazer/activity/heritage.rb

@@ -1,30 +0,0 @@
-module Trailblazer
-  # This is copied from the Declarative gem. This might get removed in favor of a real heritage gem.
-  class Activity
-    class Heritage < Array
-      # Record inheritable assignments for replay in an inheriting class.
-      def record(method, *args, &block)
-        self << { method: method, args: args, block: block }
-      end
-
-      # Replay the recorded assignments on inheritor.
-      # Accepts a block that will allow processing the arguments for every recorded statement.
-      def call(inheritor, &block)
-        each { |cfg| call!(inheritor, cfg, &block) }
-      end
-
-    private
-      def call!(inheritor, cfg)
-        yield cfg if block_given? # allow messing around with recorded arguments.
-
-        inheritor.send(cfg[:method], *cfg[:args], &cfg[:block])
-      end
-
-      module Accessor
-        def heritage
-          @heritage ||= Heritage.new
-        end
-      end
-    end
-  end
-end

data/lib/trailblazer/activity/magnetic/builder/block.rb

@@ -1,37 +0,0 @@
-module Trailblazer
-  module Activity::Magnetic
-    # Mutable DSL object.
-    #
-    # This is the only object mutated when building the ADDS, and it's only
-    # used when using block-syntax, such as
-    #   Path.plan do
-    #     # ..
-    #   end
-    class Builder::Block
-      def initialize(builder)
-        @builder = builder
-        @adds    = [] # mutable
-      end
-
-      # Evaluate user's block and return the new ADDS.
-      # Used in Builder::plan or in nested DSL calls.
-      def call(&block)
-        instance_exec(&block)
-        @adds
-      end
-
-      [:task, :step, :pass, :fail].each do |name| # create :step, :pass, :task, etc.
-        define_method(name) { |*args, &block| capture_adds(name, *args, &block) } # def step(..) => forward to builder, track ADDS
-      end
-
-      extend Forwardable
-      def_delegators :@builder, :Output, :Path, :End # TODO: make this official.
-
-      # #task, #step, etc. are called via the immutable builder.
-      def capture_adds(name, *args, &block)
-        adds, *returned_options = @builder.send(name, *args, &block)
-        @adds += adds
-      end
-    end
-  end
-end

data/lib/trailblazer/activity/process.rb

@@ -1,16 +0,0 @@
-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