trailblazer-operation 0.1.3 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 2f371c58b3c8fcd88c0c12a5e764be7a807c83c2
-  data.tar.gz: 67e41d4d0b7e0480a5948b45a2b53b4f56170ba9
+SHA256:
+  metadata.gz: aa73a58eaa839d57774f73fe429398d0902e0e60e1bc3544f47762a773708140
+  data.tar.gz: b6ceaf6448980129f728fcbad8914558d4556517c20f0a65ff1bbcfa4f70340b
 SHA512:
-  metadata.gz: '00591cd8d45d48b909d03042e486ac14496c0156455ec89222e7a68b059e12c4398b38e6a6265e4e971f4735d9cd2e4f675d2a73749a2baf3fca9bc42680841d'
-  data.tar.gz: f4aefde8d80cd7f822fbccf3ef9e513650db0f5caafc21cda3041e9fe6a9d220ea43eae000390933cf2d9546e04e5fc7d90dd41f5e72ae6d664c67701fb938ab
+  metadata.gz: 6d98db1f3a941c4547f0145148c3675c7892f535cbd90f7f30d722abfdb8b657979f21c2d383f7d656e064619738a250341538eddf6fb0d8d066131cb75433de
+  data.tar.gz: dda3c25bc10b64892344f5cdbf9ae3329dc10354f41b8b9907a383714dda6542c8607bc278b04a1e039687045a32b3cf30c58a8f0a15298bc60339c13569bd90

data/CHANGES.md

@@ -14,6 +14,14 @@ lots of work on the DSL specific parts.
 
 params:, rest: ..
 
+## 0.2.0
+
+* Cleanly separate `Activity` and `Operation` responsibilities. An operation is nothing more but a class around an activity, hosting instance methods and implementing inheritance.
+
+## 0.1.4
+
+* `TaskWrap.arguments_for_call` now returns the correct `circuit_options` where the `:runner` etc.'s already merged.
+
 ## 0.1.3
 
 * New taskWrap API for `activity` 0.3.2.

data/Gemfile

@@ -13,12 +13,12 @@ gem "benchmark-ips"
 # gem "trailblazer-circuit", git: "https://github.com/trailblazer/trailblazer-circuit"
 # gem "trailblazer-activity", path: "../trailblazer-activity"
 # gem "trailblazer-developer", path: "../developer"
-gem "trailblazer-developer", git: "https://github.com/trailblazer/trailblazer-developer"
+# gem "trailblazer-developer", git: "https://github.com/trailblazer/trailblazer-developer"
 # gem "representable", path: "../representable"
 
 # gem "raise", path: "../raise"
 
 # gem "declarative", path: "../declarative"
 
-gem "trailblazer-activity", path: "../trailblazer-circuit"
+# gem "trailblazer-activity", path: "../circuit"
 # gem "trailblazer-activity", git: "https://github.com/trailblazer/trailblazer-activity"

data/lib/trailblazer/operation.rb

@@ -7,20 +7,19 @@ require "trailblazer/container_chain"
 
 require "trailblazer/activity"
 require "trailblazer/activity/magnetic"
-require "trailblazer/activity/wrap"
+
 
 require "trailblazer/operation/variable_mapping"
 
+require "trailblazer/operation/heritage"
 require "trailblazer/operation/public_call"      # TODO: Remove in 3.0.
 require "trailblazer/operation/skill"
 require "trailblazer/operation/deprecated_macro" # TODO: remove in 2.2.
 require "trailblazer/operation/result"
 require "trailblazer/operation/railway"
 
-require "trailblazer/operation/railway/task_builder"
 require "trailblazer/operation/railway/fast_track"
 require "trailblazer/operation/railway/normalizer"
-require "trailblazer/operation/task_wrap"
 require "trailblazer/operation/trace"
 
 require "trailblazer/operation/railway/macaroni"
@@ -29,6 +28,18 @@ module Trailblazer
   # The Trailblazer-style operation.
   # Note that you don't have to use our "opinionated" version with result object, skills, etc.
   class Operation
+
+    module FastTrackActivity
+      builder_options = {
+        track_end:     Railway::End::Success.new(:success, semantic: :success),
+        failure_end:   Railway::End::Failure.new(:failure, semantic: :failure),
+        pass_fast_end: Railway::End::PassFast.new(:pass_fast, semantic: :pass_fast),
+        fail_fast_end: Railway::End::FailFast.new(:fail_fast, semantic: :fail_fast),
+      }
+
+      extend Activity::FastTrack( pipeline: Railway::Normalizer::Pipeline, builder_options: builder_options )
+    end
+
     extend Skill::Accessors        # ::[] and ::[]= # TODO: fade out this usage.
 
     def self.inherited(subclass)
@@ -37,69 +48,54 @@ module Trailblazer
       heritage.(subclass)
     end
 
-    module Process
-      def initialize!
-        initialize_activity_dsl!
-        recompile_process!
-      end
-
-      # builder is stateless, it's up to you to save @adds somewhere.
-      def initialize_activity_dsl!
-        builder_options = {
-          track_end:     Railway::End::Success.new(:success, semantic: :success),
-          failure_end:   Railway::End::Failure.new(:failure, semantic: :failure),
-          pass_fast_end: Railway::End::PassFast.new(:pass_fast, semantic: :pass_fast),
-          fail_fast_end: Railway::End::FailFast.new(:fail_fast, semantic: :fail_fast),
-        }
-
-        @builder, @adds = Activity::Magnetic::Builder::FastTrack.for( build_normalizer.freeze, builder_options )
-        @debug          = {}
-      end
-
-      def recompile_process!
-        @process, @outputs = Activity::Recompile.( @adds )
-      end
+    def self.initialize!
+      @activity = FastTrackActivity.clone
+    end
 
-      def outputs
-        @outputs
-      end
 
-      include Activity::Interface
+    extend Activity::Interface
 
+    module Process
       # Call the actual {Process} with the options prepared in PublicCall.
-      def __call__(args, circuit_options={})
-        @process.( args, circuit_options.merge( exec_context: new ) )
+      #
+      # @private
+      def __call__(args, argumenter: [], **circuit_options)
+        @activity.( args, circuit_options.merge(
+            exec_context: new,
+            argumenter:  argumenter + [ Activity::TaskWrap.method(:arguments_for_call) ], # FIXME: should we move this outside?
+          )
+        )
       end
 
-      private
-
-      def build_normalizer
-        Railway::Normalizer.new
+      def decompose
+        @activity.decompose.merge( activity: @activity )
       end
     end
 
     extend Process # make ::call etc. class methods on Operation.
 
-    extend Activity::Heritage::Accessor
+    extend Heritage::Accessor
 
-    extend Activity::DSL # #_task
-    # delegate step, pass and fail via Operation::_task to the @builder, and save results in @adds.
-    extend Activity::DSL.def_dsl! :step
-    extend Activity::DSL.def_dsl! :pass
-    extend Activity::DSL.def_dsl! :fail
     class << self
+      extend Forwardable # TODO: test those helpers
+      def_delegators :@activity, :Path, :Output, :End
+      def_delegators :@activity, :outputs, :debug
+
+      def step(task, options={}, &block); add_task!(:step, task, options, &block) end
+      def pass(task, options={}, &block); add_task!(:pass, task, options, &block) end
+      def fail(task, options={}, &block); add_task!(:fail, task, options, &block) end
+
       alias_method :success, :pass
       alias_method :failure, :fail
 
-      extend Forwardable # TODO: test those helpers
-      def_delegators :@builder, :Path, :Output, :End #, :task
+      def add_task!(name, task, options, &block)
+        heritage.record(name, task, options, &block)
+        @activity.send(name, task, options, &block)
+      end
     end
 
     extend PublicCall              # ::call(params, { current_user: .. })
     extend Trace                   # ::trace
-
-
-    include Railway::TaskWrap
   end
 end
 

data/lib/trailblazer/operation/deprecated_macro.rb

@@ -2,18 +2,18 @@
 module Trailblazer
   module Operation::DeprecatedMacro
     # Allows old macros with the `(input, options)` signature.
-    def self.call(proc, options={})
+    def self.call(proc, options)
       warn %{[Trailblazer] Macros with API (input, options) are deprecated. Please use the "Task API" signature (options, flow_options) or use a simpler Callable. (#{proc})}
 
       wrapped_proc = ->( (options, flow_options), **circuit_options ) do
         result = proc.(circuit_options[:exec_context], options) # run the macro, with the deprecated signature.
 
-        direction = Operation::Railway::TaskBuilder.binary_direction_for(result, Activity::Right, Activity::Left)
+        direction = Activity::TaskBuilder::Binary.binary_direction_for(result, Activity::Right, Activity::Left)
 
         return direction, [options, flow_options]
       end
 
-      return wrapped_proc, options
+      options.merge( task: wrapped_proc )
     end
   end
 end

data/lib/trailblazer/operation/heritage.rb

@@ -0,0 +1,30 @@
+module Trailblazer
+  # This is copied from the Declarative gem. This might get removed in favor of a real heritage gem.
+  class Operation
+    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/operation/inject.rb

@@ -6,7 +6,9 @@ module Trailblazer
       # injection but need a default parameter to be set if not injected.
       # @returns ADDS
       def self.Defaults(default_dependencies)
-        Activity::Magnetic::Builder::Path.plan do
+        Module.new do
+          extend Activity::Path::Plan()
+
           task ReverseMergeDefaults.new( default_dependencies ),
             id:     "ReverseMergeDefaults#{default_dependencies}",
             before: "task_wrap.call_task"

data/lib/trailblazer/operation/inspect.rb

@@ -17,8 +17,7 @@ module Trailblazer
     def call(operation, options={ style: :line })
       # TODO: better introspection API.
 
-      adds = operation.instance_variable_get(:@adds)
-      alterations = Activity::Magnetic::Builder::Finalizer.adds_to_alterations(adds)
+      alterations = Activity::Magnetic::Builder::Finalizer.adds_to_alterations(operation.decompose[:adds])
       # DISCUSS: any other way to retrieve the Alterations?
 
       # pp alterations

data/lib/trailblazer/operation/public_call.rb

@@ -10,6 +10,8 @@ class Trailblazer::Operation
     # In workflows/Nested compositions, this method is not used anymore and it might probably
     # get removed in future versions of TRB. Currently, we use Operation::__call__ as an alternative.
     #
+    #
+    # @note Do not override this method as it will be removed in future versions. Also, you will break tracing.
     # @return Operation::Railway::Result binary result object
     def call(*args)
       ctx = PublicCall.options_for_public_call(*args)
@@ -21,11 +23,9 @@ class Trailblazer::Operation
       Railway::Result(last_signal, options, flow_options)
     end
 
-    private
     # Compile a Context object to be passed into the Activity::call.
+    # @private
     def self.options_for_public_call(options={}, *containers)
-      # options, *containers = Deprecations.accept_positional_options(params, options, *containers) # TODO: make this optional for "power users".
-
       # generate the skill hash that embraces runtime options plus potential containers, the so called Runtime options.
       # This wrapping is supposed to happen once in the entire system.
 
@@ -35,28 +35,5 @@ class Trailblazer::Operation
 
       ctx = Trailblazer::Context(immutable_options)
     end
-
-    module Deprecations
-      # Merge the first argument to the public Create.() into the second.
-      #
-      # DISCUSS: this is experimental since we can never know whether the call is the old or new API.
-      #
-      # The following situations are _not_ covered here:
-      # * You're using a Hash instance as a container.
-      # * You're using more than one container.
-      #
-      # If you do so (we're assuming you know what you're doing then), please update your `call`s.
-      def self.accept_positional_options( *args )
-        if args.size == 1 && args[0].instance_of?(Hash) # new style, you're doing it right.
-          args
-        elsif args.size == 2 && args[0].instance_of?(Hash) && !args[1].instance_of?(Hash) # new style with container, you're doing it right.
-          args
-        else
-          warn "[Trailblazer] Passing two positional arguments to `Operation.( params, current_user: .. )` is deprecated. Please use one hash like `Operation.( params: params, current_user: .. )`"
-          params, options, *containers = args
-          [ options.merge("params" => params), *containers ]
-        end
-      end
-    end
   end
 end

data/lib/trailblazer/operation/railway/macaroni.rb

@@ -7,7 +7,7 @@ module Trailblazer
     #   def my_step( params:, options:, ** )
     module Macaroni
       def self.call(user_proc)
-        Task.new( Trailblazer::Option.build( Macaroni::Option, user_proc ), user_proc )
+        Activity::TaskBuilder::Task.new( Trailblazer::Option.build( Macaroni::Option, user_proc ), user_proc )
       end
 
       class Option < Trailblazer::Option

data/lib/trailblazer/operation/railway/normalizer.rb

@@ -5,73 +5,54 @@ module Trailblazer
     # task via {TaskBuilder} in order to translate true/false to `Right` or `Left`.
     #
     # The Normalizer sits in the `@builder`, which receives all DSL calls from the Operation subclass.
-    class Normalizer
-      def initialize(task_builder: TaskBuilder, **options)
-        @task_builder = task_builder
-      end
-
-      def call(task, options, unknown_options, sequence_options)
-        wrapped_task, options =
-          if task.is_a?(::Hash) # macro.
-            [
-              task[:task],
-              task.merge(options) # Note that the user options are merged over the macro options.
-            ]
-          elsif task.is_a?(Array) # TODO remove in 2.2
-            Operation::DeprecatedMacro.( *task )
-          else # user step
-            [
-              @task_builder.(task),
-              { id: task }.merge(options) # default :id
-            ]
-          end
-
-        options, unknown_options = deprecate_name(options, unknown_options) # TODO remove in 2.2
+    module Normalizer
+      Pipeline = Activity::Magnetic::Normalizer::Pipeline.clone
 
-        raise "No :id given for #{wrapped_task}" unless options[:id]
+      Pipeline.module_eval do
+        # Handle the :override option which is specific to Operation.
+        def self.override(ctx, task:, options:, sequence_options:, **)
+          options, locals  = Activity::Magnetic::Options.normalize(options, [:override])
+          sequence_options = sequence_options.merge( replace: options[:id] ) if locals[:override]
 
-        options = defaultize(task, options) # :plus_poles
-
-
-        options, locals, sequence_options = override(task, options, sequence_options) # :override
+          ctx[:options], ctx[:sequence_options] = options, sequence_options
+        end
 
-        return wrapped_task, options, unknown_options, sequence_options
-      end
+        # TODO remove in 2.2
+        def self.deprecate_macro_with_two_args(ctx, task:, **)
+          return true unless task.is_a?(Array) # TODO remove in 2.2
 
-      # Merge user options over defaults.
-      def defaultize(task, options)
-        {
-          plus_poles: InitialPlusPoles(),
-        }.merge(options)
-      end
+          ctx[:options] = Operation::DeprecatedMacro.( *task )
+        end
 
-      # Handle the :override option which is specific to Operation.
-      def override(task, options, sequence_options)
-        options, locals  = Activity::Magnetic::Builder.normalize(options, [:override])
-        sequence_options = sequence_options.merge( replace: options[:id] ) if locals[:override]
+        # TODO remove in 2.2
+        def self.deprecate_name(ctx, local_options:, connection_options:, **)
+          connection_options, deprecated_options = Activity::Magnetic::Options.normalize(connection_options, [:name])
+          local_options, _deprecated_options           = Activity::Magnetic::Options.normalize(local_options, [:name])
 
-        return options, locals, sequence_options
-      end
+          deprecated_options = deprecated_options.merge(_deprecated_options)
 
-      def InitialPlusPoles
-        Activity::Magnetic::DSL::PlusPoles.new.merge(
-          Activity.Output(Activity::Right, :success) => nil,
-          Activity.Output(Activity::Left,  :failure) => nil,
-        )
-      end
+          local_options = local_options.merge( name: deprecated_options[:name] ) if deprecated_options[:name]
 
-      def deprecate_name(options, unknown_options) # TODO remove in 2.2
-        unknown_options, deprecated_options = Activity::Magnetic::Builder.normalize(unknown_options, [:name])
+          local_options, locals = Activity::Magnetic::Options.normalize(local_options, [:name])
+          if locals[:name]
+            warn "[Trailblazer] The :name option for #step, #success and #failure has been renamed to :id."
+            local_options = local_options.merge(id: locals[:name])
+          end
 
-        options = options.merge( name: deprecated_options[:name] ) if deprecated_options[:name]
+          ctx[:local_options], ctx[:connection_options] = local_options, connection_options
+        end
 
-        options, locals = Activity::Magnetic::Builder.normalize(options, [:name])
-        if locals[:name]
-          warn "[Trailblazer] The :name option for #step, #success and #failure has been renamed to :id."
-          options = options.merge(id: locals[:name])
+        def self.raise_on_missing_id(ctx, local_options:, **)
+          raise "No :id given for #{local_options[:task]}" unless local_options[:id]
+          true
         end
-        return options, unknown_options
+
+        # add more normalization tasks to the existing Magnetic::Normalizer::Pipeline
+        task Activity::TaskBuilder::Binary.( method(:deprecate_macro_with_two_args) ), before: "split_options"
+        task Activity::TaskBuilder::Binary.( method(:deprecate_name) )
+        task Activity::TaskBuilder::Binary.( method(:override) )
+        task Activity::TaskBuilder::Binary.( method(:raise_on_missing_id) )
       end
-    end
+    end # Normalizer
   end
 end

data/lib/trailblazer/operation/railway/task_builder.rb

@@ -20,7 +20,6 @@ module Trailblazer
       def initialize(task, user_proc)
         @task      = task
         @user_proc = user_proc
-
         freeze
       end
 

data/lib/trailblazer/operation/trace.rb

@@ -1,21 +1,25 @@
 module Trailblazer
   class Operation
     module Trace
+      # @note The problem in this method is, we have redundancy with Operation::PublicCall
       def self.call(operation, *args)
-        ctx = PublicCall.send(:options_for_public_call, *args)
+        ctx = PublicCall.options_for_public_call(*args)   # redundant with PublicCall::call.
 
-        # let Activity::Trace::call handle all parameters, just make sure it calls Operation.__call__
-        call_block = ->(operation, *args) { operation.__call__(*args) }
+        # Prepare the tracing-specific arguments. This is only run once for the entire circuit!
+        operation, (options, flow_options), circuit_options = Trailblazer::Activity::Trace.arguments_for_call( operation, [ctx, {}], {} )
 
-        stack, direction, options, flow_options = Activity::Trace.(
-          operation,
-          ctx,
-          &call_block # instructs Trace to use __call__.
-        )
+        circuit_options = circuit_options.merge({ argumenter: [ Trailblazer::Activity::Introspect.method(:arguments_for_call) ] }) # this is called for every Activity.
 
-        result = Railway::Result(direction, options)
 
-        Result.new(result, stack)
+        last_signal, (options, flow_options) =
+          operation.__call__( # FIXME: this is the only problem.
+            [options, flow_options],
+            circuit_options
+          )
+
+        result = Railway::Result(last_signal, options)    # redundant with PublicCall::call.
+
+        Result.new(result, flow_options[:stack].to_a)
       end
 
       # `Operation::trace` is included for simple tracing of the flow.
@@ -37,7 +41,7 @@ module Trailblazer
         end
 
         def wtf
-          Activity::Trace::Present.tree(@stack)
+          Trailblazer::Activity::Trace::Present.tree(@stack)
         end
 
         def wtf?

data/lib/trailblazer/operation/variable_mapping.rb

@@ -1,5 +1,5 @@
-class Trailblazer::Activity
-  module Wrap
+class Trailblazer::Activity < Module
+  module TaskWrap
     # TaskWrap step to compute the incoming {Context} for the wrapped task.
     # This allows renaming, filtering, hiding, of the options passed into the wrapped task.
     #

data/lib/trailblazer/operation/version.rb

@@ -1,5 +1,5 @@
 module Trailblazer
   class Operation
-    VERSION = "0.1.3"
+    VERSION = "0.2.0"
   end
 end

data/test/docs/macaroni_test.rb

@@ -10,7 +10,7 @@ class MacaroniTaskBuilderTest < Minitest::Spec
   #:create
   class Memo::Create < Trailblazer::Operation
     #~ign
-    Normalizer = Railway::Normalizer.new( task_builder: Railway::KwSignature )
+    Normalizer, _ = Trailblazer::Activity::Magnetic::Normalizer.build( task_builder: Railway::KwSignature, pipeline: Railway::Normalizer::Pipeline )
 
     step :create_model, normalizer: Normalizer
     step :save,         normalizer: Normalizer

data/test/docs/wiring_test.rb

@@ -471,3 +471,89 @@ class WiringsDocCustomConnectionTest < Minitest::Spec
     result.inspect(:new?, :upload, :validate, :validation_error, :index).must_equal %{<Result:false [true, true, false, true, nil] >}
   end
 end
+
+class WiringsDocDeciderTest < Minitest::Spec
+  Memo = Class.new(WiringDocsTest::Memo)
+
+  #:decider
+  class Memo::Upsert < Trailblazer::Operation
+    step :find_model, Output(:failure) => :create_route
+    step :update
+    step :create, magnetic_to: [:create_route]
+    step :save
+    #~decm
+    def find_model(options, id:nil, **)
+      options[:model] = Memo.find(id)
+    end
+
+    def find_model(options, id:, **)
+      options[:find_model] = id
+    end
+    def update(options, **)
+      options[:update] = true
+    end
+    def create(options, **)
+      options[:create] = true
+    end
+    def save(options, **)
+      options[:save] = true
+    end
+    #~decm end
+  end
+  #:decider end
+
+  it "goes the create route" do
+    Memo::Upsert.( id: false ).inspect(:find_model, :update, :create, :save).must_equal %{<Result:true [false, nil, true, true] >}
+  end
+
+  it "goes the update route" do
+    Memo::Upsert.( id: true ).inspect(:find_model, :update, :create, :save).must_equal %{<Result:true [true, true, nil, true] >}
+  end
+end
+
+class WiringsDocEndTest < Minitest::Spec
+  Memo = Class.new(WiringDocsTest::Memo)
+
+  #:end
+  class Memo::Update < Trailblazer::Operation
+    step :find_model, Output(:failure) => End("End.model_not_found", :model_not_found)
+    step :update
+    fail :db_error
+    step :save
+    #~methods
+    def find_model(options, id:nil, **)
+      options[:model] = Memo.find(id)
+    end
+
+    def find_model(options, id:, **)
+      options[:find_model] = id
+    end
+    def update(options, update: true, **)
+      options[:update] = update
+    end
+    def db_error(options, **)
+      options[:db_error] = 1
+    end
+    def save(options, **)
+      options[:save] = true
+    end
+    #~methods end
+  end
+  #:end end
+
+  it "goes success path" do
+    Memo::Update.( id: true ).inspect(:find_model, :update, :save, :db_error).must_equal %{<Result:true [true, true, true, nil] >}
+  end
+
+  it "errors out on End.model_not_found" do
+    result = Memo::Update.( id: false )
+    result.inspect(:find_model, :update, :save, :db_error).must_equal %{<Result:false [false, nil, nil, nil] >}
+    result.event.instance_variable_get(:@options).must_equal(semantic: :model_not_found)
+  end
+
+  it "takes normal error track" do
+    result = Memo::Update.( id: true, update: false )
+    result.inspect(:find_model, :update, :save, :db_error).must_equal %{<Result:false [true, false, nil, 1] >}
+    result.event.instance_variable_get(:@options).must_equal(semantic: :failure)
+  end
+end

data/test/fast_track_test.rb

@@ -183,7 +183,7 @@ class NestedFastTrackTest < Minitest::Spec
     end
 
     # it { puts Trailblazer::Activity::Introspect.Cct(update.instance_variable_get(:@process)) }
-    it { puts Trailblazer::Activity::Magnetic::Introspect.seq( update ) }
+    it { update.decompose[0]  }
     # Edit returns End.success
     it { update.(edit_return: true).inspect("a", "b", "f").must_equal %{<Result:true [1, 2, nil] >} }
     # Edit returns End.failure

data/test/introspect_test.rb

@@ -25,6 +25,7 @@ class IntrospectTest < Minitest::Spec
 
   describe "#collect" do
     it "iterates over each task element in the top activity" do
+      skip
       all_tasks = Activity::Introspect.collect(activity) do |task, connections|
         task
       end

data/test/ruby-2.0.0/operation_test.rb

@@ -59,15 +59,3 @@ class DeclarativeApiTest < Minitest::Spec
   it { Update.(decide: true).inspect("a", "b", "c").must_equal %{<Result:true [false, true, nil] >} }
   it { Update.(decide: false).inspect("a", "b", "c").must_equal %{<Result:false [false, false, true] >} }
 end
-
-
-=begin
-module MiniTest::Assertions
-  def assert_inspect(text, subject)
-    circuit, _ = subject.values
-    map, _ = circuit.to_fields
-    map.inspect.gsub(/0x.+?lambda\)/, "").gsub("Trailblazer::Circuit::", "").gsub("AlterTest::", "").must_equal(text)
-  end
-end
-Trailblazer::Circuit::Activity.infect_an_assertion :assert_inspect, :must_inspect
-=end

data/test/task_wrap_test.rb

@@ -15,14 +15,17 @@ class TaskWrapTest < Minitest::Spec
       task: MyMacro,
       id: "MyMacro",
 
-      runner_options: {
-        merge: Trailblazer::Activity::Magnetic::Builder::Path.plan do
-          task Trailblazer::Operation::Wrap::Inject::ReverseMergeDefaults.new( contract: "MyDefaultContract" ),
-            id:     "inject.my_default",
-            before: "task_wrap.call_task"
-        end
-      }
-
+      extension: [
+        Trailblazer::Activity::TaskWrap::Merge.new(
+          Module.new do
+            extend Trailblazer::Activity::Path::Plan()
+
+            task Trailblazer::Operation::Wrap::Inject::ReverseMergeDefaults.new( contract: "MyDefaultContract" ),
+              id:     "inject.my_default",
+              before: "task_wrap.call_task"
+          end
+        )
+      ]
     )
 
     def model!(options, **)
@@ -42,7 +45,6 @@ class TaskWrapTest < Minitest::Spec
   it do
     direction, (options, _) = Create.__call__( [{}, {}] )
 
-
     inspect_hash(options, "options.contract", :contract, "MyMacro.contract").
       must_equal %{{"options.contract"=>nil, :contract=>"MyDefaultContract", "MyMacro.contract"=>"MyDefaultContract"}}
   end
@@ -73,12 +75,16 @@ class TaskWrapTest < Minitest::Spec
     step(
       task:           AnotherMacro,
       id:             "AnotherMacro",
-      runner_options: {
-        merge: Trailblazer::Activity::Magnetic::Builder::Path.plan do
-          task Trailblazer::Operation::Wrap::Inject::ReverseMergeDefaults.new( another_contract: "AnotherDefaultContract" ), id: "inject.my_default",
-          before: "task_wrap.call_task"
-        end
-      }
+      extension: [
+        Trailblazer::Activity::TaskWrap::Merge.new(
+          Module.new do
+            extend Trailblazer::Activity::Path::Plan()
+
+            task Trailblazer::Operation::Wrap::Inject::ReverseMergeDefaults.new( another_contract: "AnotherDefaultContract" ), id: "inject.my_default",
+            before: "task_wrap.call_task"
+          end
+        )
+      ]
     )
   end
 

data/test/trace_test.rb

@@ -28,7 +28,8 @@ class TraceTest < Minitest::Spec
     stack, _ = Trailblazer::Activity::Trace.(
       Create,
       [
-        { a_return: true, "params" => {} },
+        { a_return: true, params: {} },
+        {}
       ]
     )
 
@@ -47,7 +48,7 @@ class TraceTest < Minitest::Spec
   end
 
   it "Operation::trace" do
-    result = Create.trace({ "params" => { x: 1 }, a_return: true })
+    result = Create.trace({ params: { x: 1 }, a_return: true })
     result.wtf.gsub(/0x\w+/, "").gsub(/@.+_test/, "").must_equal %{|-- #<Trailblazer::Activity::Start:>
 |-- Create.task.a
 |-- MyNested

data/test/variable_mapping_test.rb

@@ -20,9 +20,11 @@ class VariableMappingTest < Minitest::Spec
   end
 
   let (:activity) do
-    Activity.build do
-      task Model
-      task Uuid
+    Module.new do
+      extend Activity::Path()
+
+      task task: Model
+      task task: Uuid
     end
   end
 
@@ -34,18 +36,22 @@ class VariableMappingTest < Minitest::Spec
       uuid_input   = ->(options) { { "a"       => options["a"]*3, "model.a" => options["model.a"] } }
       uuid_output  = ->(options) { { "uuid.a"  => options["a"] } }
 
-      runtime = Hash.new([])
+      runtime = {}
 
       # add filters around Model.
-      runtime[ Model ] = Activity::Magnetic::Builder::Path.plan do
-        task Activity::Wrap::Input.new( model_input ),   id: "task_wrap.input", before: "task_wrap.call_task"
-        task Activity::Wrap::Output.new( model_output ), id: "task_wrap.output", before: "End.success", group: :end
+      runtime[ Model ] = Module.new do
+        extend Activity::Path::Plan()
+
+        task Activity::TaskWrap::Input.new( model_input ),   id: "task_wrap.input", before: "task_wrap.call_task"
+        task Activity::TaskWrap::Output.new( model_output ), id: "task_wrap.output", before: "End.success", group: :end
       end
 
       # add filters around Uuid.
-      runtime[ Uuid ] = Activity::Magnetic::Builder::Path.plan do
-        task Activity::Wrap::Input.new( uuid_input ),   id: "task_wrap.input", before: "task_wrap.call_task"
-        task Activity::Wrap::Output.new( uuid_output ), id: "task_wrap.output", before: "End.success", group: :end
+      runtime[ Uuid ] = Module.new do
+        extend Activity::Path::Plan()
+
+        task Activity::TaskWrap::Input.new( uuid_input ),   id: "task_wrap.input", before: "task_wrap.call_task"
+        task Activity::TaskWrap::Output.new( uuid_output ), id: "task_wrap.output", before: "End.success", group: :end
       end
 
       signal, (options, flow_options) = activity.(
@@ -55,8 +61,9 @@ class VariableMappingTest < Minitest::Spec
       ],
 
       wrap_runtime: runtime, # dynamic additions from the outside (e.g. tracing), also per task.
-      runner: Activity::Wrap::Runner,
-      wrap_static: Hash.new( Activity::Wrap.initial_activity ), # per activity?
+      runner: Activity::TaskWrap::Runner,
+      argumenters: [ Activity::TaskWrap::NonStatic.method(:arguments_for_call) ],
+      wrap_static: Hash.new( Activity::TaskWrap.initial_activity ),
     )
 
     signal.must_equal activity.outputs[:success].signal

data/test/wiring/defaults_test.rb

@@ -158,7 +158,7 @@ class WireDefaultsEarlyExitSuccessTest < Minitest::Spec
     end
   end
 
-  it { puts Trailblazer::Activity::Magnetic::Introspect.seq( Connect ) }
+  # it { puts Trailblazer::Activity::Magnetic::Introspect.seq( Connect.decompose.first ) }
 
   # a => true
   it { Connect.( a_return: true, b_return: true,data: []).inspect(:data).must_equal %{<Result:true [[:a, :b, :d]] >} }

data/trailblazer-operation.gemspec

@@ -17,7 +17,7 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
-  spec.add_dependency "trailblazer-activity", ">= 0.3.2", "< 0.4.0"
+  spec.add_dependency "trailblazer-activity", ">= 0.4.0", "< 0.5.0"
   spec.add_dependency "trailblazer-context", ">= 0.1.1", "< 0.3.0"
 
   spec.add_development_dependency "bundler"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: trailblazer-operation
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.2.0
 platform: ruby
 authors:
 - Nick Sutterer
 autorequire: 
 bindir: bin
 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: trailblazer-activity
@@ -16,20 +16,20 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.3.2
+        version: 0.4.0
     - - "<"
       - !ruby/object:Gem::Version
-        version: 0.4.0
+        version: 0.5.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.3.2
+        version: 0.4.0
     - - "<"
       - !ruby/object:Gem::Version
-        version: 0.4.0
+        version: 0.5.0
 - !ruby/object:Gem::Dependency
   name: trailblazer-context
   requirement: !ruby/object:Gem::Requirement
@@ -107,6 +107,7 @@ files:
 - Rakefile
 - lib/trailblazer/operation.rb
 - lib/trailblazer/operation/deprecated_macro.rb
+- lib/trailblazer/operation/heritage.rb
 - lib/trailblazer/operation/inject.rb
 - lib/trailblazer/operation/inspect.rb
 - lib/trailblazer/operation/public_call.rb
@@ -117,7 +118,6 @@ files:
 - lib/trailblazer/operation/railway/task_builder.rb
 - lib/trailblazer/operation/result.rb
 - lib/trailblazer/operation/skill.rb
-- lib/trailblazer/operation/task_wrap.rb
 - lib/trailblazer/operation/trace.rb
 - lib/trailblazer/operation/variable_mapping.rb
 - lib/trailblazer/operation/version.rb
@@ -171,7 +171,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.8
+rubygems_version: 2.7.3
 signing_key: 
 specification_version: 4
 summary: Trailblazer's operation object with railway flow and integrated error handling.

data/lib/trailblazer/operation/task_wrap.rb

@@ -1,68 +0,0 @@
-module Trailblazer
-  module Operation::Railway
-    module TaskWrap
-      def self.included(includer)
-        includer.extend ClassMethods # ::__call__, ::inititalize_task_wraps!
-        includer.extend DSL
-
-        includer.initialize_task_wraps!
-      end
-
-      module ClassMethods
-        def initialize_task_wraps!
-          heritage.record :initialize_task_wraps!
-
-          # The map of task_wrap per step/task. Note that it defaults to Wrap.initial_activity.
-          # This gets extended at compile-time for particular tasks as the steps are created via the DSL.
-          self["__static_task_wraps__"] = ::Hash.new(Activity::Wrap.initial_activity)
-        end
-
-        # __call__ prepares `flow_options` and `static_wraps` for {TaskWrap::Runner}.
-        def __call__(args, **circuit_args)
-          args, _circuit_args = TaskWrap.arguments_for_call(self, args, **circuit_args)
-
-          super( args, circuit_args.merge(_circuit_args) ) # Railway::__call__
-        end
-      end
-
-      def self.arguments_for_call(operation, (options, flow_options), **circuit_args)
-        wrap_static = operation["__static_task_wraps__"]
-
-        circuit_args = {
-          runner:        Activity::Wrap::Runner,
-                  # FIXME: this sucks, why do we even need to pass an empty runtime there?
-          wrap_runtime: circuit_args[:wrap_runtime] || ::Hash.new([]), # FIXME:this sucks. (was:) this overwrites wrap_runtime from outside.
-          wrap_static:  wrap_static,
-        }
-
-        return [ options, flow_options ], circuit_args
-      end
-
-      module DSL
-        # TODO: this override is hard to follow, we should have a pipeline circuit in DSL to add behavior.
-        # @private
-        def _task(*args)
-          returned = super # TODO: do this with a circuit :)
-          adds, (task, local_options) = returned
-
-          runner_options = local_options[:runner_options]
-
-          runner_options and apply_adds_from_runner_options!( task, runner_options )
-
-          returned
-        end
-
-        # Extend the static wrap for a specific task, at compile time.
-        def apply_adds_from_runner_options!(task, merge:raise, **ignored)
-          static_wrap = self["__static_task_wraps__"][task]
-
-          # macro might want to apply changes to the static task_wrap (e.g. Inject)
-          self["__static_task_wraps__"][task] = Activity::Magnetic::Builder.merge( static_wrap, merge )
-        end
-      end
-    end # TaskWrap
-  end
-end
-
-
-# |-- Railway::Call "insert.exec_context"