trailblazer-operation 0.4.1 → 0.6.0

data/lib/trailblazer/operation/class_dependencies.rb

@@ -16,7 +16,7 @@ class Trailblazer::Operation
   # The use of this module is not encouraged and it is only here for backward-compatibility.
   # Instead, please pass dependencies via containers, locals, or macros into the respective steps.
   module ClassDependencies
-    def call_with_circuit_interface( (ctx, flow_options), **circuit_options )
+    def call_with_circuit_interface((ctx, flow_options), **circuit_options)
       @skills.each { |name, value| ctx[name] ||= value } # this resembles the behavior in 2.0. we didn't say we liked it.
 
       super

data/lib/trailblazer/operation/container.rb

@@ -0,0 +1,14 @@
+module Trailblazer
+  module Operation::Container
+    def options_for_public_call(options={}, *containers)
+      # 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.
+
+      hash_transformer = ->(containers) { containers[0].to_hash } # FIXME: don't transform any containers into kw args.
+
+      immutable_options = Trailblazer::Context::ContainerChain.new([options, *containers], to_hash: hash_transformer)
+
+      Trailblazer::Context(immutable_options)
+    end
+  end
+end

data/lib/trailblazer/operation/deprecated_macro.rb

@@ -5,7 +5,7 @@ module Trailblazer
     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
+      wrapped_proc = ->((options, flow_options), **circuit_options) do
         result = proc.(circuit_options[:exec_context], options) # run the macro, with the deprecated signature.
 
         direction = Activity::TaskBuilder.binary_signal_for(result, Activity::Right, Activity::Left)
@@ -13,7 +13,7 @@ module Trailblazer
         return direction, [options, flow_options]
       end
 
-      options.merge( task: wrapped_proc )
+      options.merge(task: wrapped_proc)
     end
   end
 end

data/lib/trailblazer/operation/public_call.rb

@@ -13,43 +13,46 @@ module Trailblazer
     #
     # @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)
-      return call_with_circuit_interface(*args) if args.any? && args[0].is_a?(Array) # This is kind of a hack that could be well hidden if Ruby had method overloading. Goal is to simplify the call/__call__ thing as we're fading out Operation::call anyway.
-      call_with_public_interface(*args)
+    def call(options = {}, *args)
+      return call_with_circuit_interface(options, *args) if options.is_a?(Array) # This is kind of a hack that could be well hidden if Ruby had method overloading. Goal is to simplify the call/__call__ thing as we're fading out Operation::call anyway.
+
+      call_with_public_interface(options, *args)
     end
 
     def call_with_public_interface(*args)
-      ctx = Operation::PublicCall.options_for_public_call(*args)
+      ctx = options_for_public_call(*args, flow_options())
 
       # call the activity.
       # This will result in invoking {::call_with_circuit_interface}.
-      last_signal, (options, flow_options) = Activity::TaskWrap.invoke(self, [ctx, {}], {})
+      # last_signal, (options, flow_options) = Activity::TaskWrap.invoke(self, [ctx, {}], {})
+      signal, (ctx, flow_options) = Activity::TaskWrap.invoke(
+        @activity,
+        [ctx, flow_options()],
+        exec_context: new
+      )
 
       # Result is successful if the activity ended with an End event derived from Railway::End::Success.
-      Operation::Railway::Result(last_signal, options, flow_options)
+      Operation::Railway::Result(signal, ctx, flow_options)
     end
 
     # This interface is used for all nested OPs (and the outer-most, too).
     def call_with_circuit_interface(args, circuit_options)
-      @activity.(
-        args,
-        circuit_options.merge(
-          exec_context: new
-        )
-      )
+      strategy_call(args, circuit_options) # FastTrack#call
+    end
+
+    def options_for_public_call(*args)
+      Operation::PublicCall.options_for_public_call(*args)
     end
 
     # Compile a Context object to be passed into the Activity::call.
     # @private
-    def self.options_for_public_call(options={}, *containers)
-      # 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.
-
-      hash_transformer = ->(containers) { containers[0].to_hash } # FIXME: don't transform any containers into kw args.
-
-      immutable_options = Trailblazer::Context::ContainerChain.new( [options, *containers], to_hash: hash_transformer ) # Runtime options, immutable.
+    def self.options_for_public_call(options, **flow_options)
+      Trailblazer::Context.for_circuit(options, {}, [options, flow_options], {})
+    end
 
-      ctx = Trailblazer::Context(immutable_options)
+    # @semi=public
+    def flow_options
+      {context_alias: {}}
     end
   end
 end

data/lib/trailblazer/operation/railway.rb

@@ -23,10 +23,9 @@ module Trailblazer
       end
 
       module End
-        class Success < Activity::End; end
-        class Failure < Activity::End; end
+        Success = Activity::Railway::End::Success
+        Failure = Activity::Railway::End::Failure
       end
-
     end # Railway
   end
 end

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

@@ -7,13 +7,13 @@ module Trailblazer
     #   def my_step( params:, options:, ** )
     module Macaroni
       def self.call(user_proc)
-        Activity::TaskBuilder::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
         # The Option#call! method prepares the arguments.
         def self.call!(proc, options, *)
-          proc.( **options.to_hash.merge( options: options ) )
+          proc.(**options.to_hash.merge(options: options))
         end
       end
     end

data/lib/trailblazer/operation/result.rb

@@ -11,7 +11,15 @@ class Trailblazer::Operation
     end
 
     def failure?
-      ! success?
+      !success?
+    end
+
+    def to_hash
+      data.to_hash
+    end
+
+    def keys
+      data.to_hash.keys
     end
 
     extend Forwardable
@@ -20,11 +28,16 @@ class Trailblazer::Operation
     # DISCUSS: the two methods below are more for testing.
     def inspect(*slices)
       return "<Result:#{success?} #{slice(*slices).inspect} >" if slices.any?
+
       "<Result:#{success?} #{@data.inspect} >"
     end
 
     def slice(*keys)
       keys.collect { |k| self[k] }
     end
+
+    private
+
+    attr_reader :data
   end
 end

data/lib/trailblazer/operation/trace.rb

@@ -2,17 +2,14 @@ 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.options_for_public_call(*args)   # redundant with PublicCall::call.
+      def self.call(operation, options)
+        ctx = PublicCall.options_for_public_call(options) # redundant with PublicCall::call.
 
-        # Prepare the tracing-specific arguments. This is only run once for the entire circuit!
-        operation, *args = Trailblazer::Activity::Trace.arguments_for_call( operation, [ctx, {}], {} )
+        stack, signal, (ctx, _flow_options) = Developer::Trace.(operation, [ctx, {}])
 
-        last_signal, (ctx, flow_options) = Activity::TaskWrap.invoke(operation, *args )
+        result = Railway::Result(signal, ctx) # redundant with PublicCall::call.
 
-        result = Railway::Result(last_signal, ctx)    # redundant with PublicCall::call.
-
-        Result.new(result, flow_options[:stack].to_a)
+        Result.new(result, stack.to_a)
       end
 
       # `Operation::trace` is included for simple tracing of the flow.
@@ -20,9 +17,9 @@ module Trailblazer
       #
       # @public
       #
-      #   Operation.trace(params, "current_user" => current_user).wtf
-      def trace(*args)
-        Trace.(self, *args)
+      #   Operation.trace(params, current_user: current_user).wtf
+      def trace(options)
+        Trace.(self, options)
       end
 
       # Presentation of the traced stack via the returned result object.
@@ -34,7 +31,7 @@ module Trailblazer
         end
 
         def wtf
-          Trailblazer::Activity::Trace::Present.(@stack)
+          Trailblazer::Developer::Trace::Present.(@stack)
         end
 
         def wtf?

data/lib/trailblazer/operation/version.rb

@@ -1,5 +1,7 @@
 module Trailblazer
-  class Operation
-    VERSION = "0.4.1"
+  module Version
+    module Operation
+      VERSION = "0.6.0"
+    end
   end
 end

data/test/benchmark/skill_resolver_benchmark.rb

@@ -11,28 +11,27 @@ normal_container = {}
   normal_container["xbla_#{i}"] = i
 end
 
-
 Benchmark.ips do |x|
-  x.report(:merge) {
+  x.report(:merge) do
     attrs = normal_container.merge(initialize_hash)
-    10.times do |i|
+    10.times do |_i|
       attrs["bla_8"]
     end
-    10.times do |i|
+    10.times do |_i|
       attrs["xbla_1"]
     end
-  }
+  end
 
-  x.report(:resolver) {
+  x.report(:resolver) do
     attrs = Trailblazer::Skill::Resolver.new(initialize_hash, normal_container)
 
-    10.times do |i|
+    10.times do |_i|
       attrs["bla_8"]
     end
-    10.times do |i|
+    10.times do |_i|
       attrs["xbla_1"]
     end
-  }
+  end
 end
 
 # Warming up --------------------------------------

data/test/call_test.rb

@@ -1,47 +1,73 @@
-require "test_helper"
+  require "test_helper"
 
 class CallTest < Minitest::Spec
-  describe "::call" do
-    class Create < Trailblazer::Operation
-      step ->(*) { true }
-      def inspect
-        "#{@skills.inspect}"
-      end
+  class Create < Trailblazer::Operation
+    step ->(*) { true }
+    def inspect
+      @skills.inspect.to_s
     end
+  end
 
-    it { Create.().must_be_instance_of Trailblazer::Operation::Railway::Result }
+  it { Create.().must_be_instance_of Trailblazer::Operation::Railway::Result }
 
-    # it { Create.({}).inspect.must_equal %{<Result:true <Skill {} {\"params\"=>{}} {\"pipetree\"=>[>operation.new]}> >} }
-    # it { Create.(name: "Jacob").inspect.must_equal %{<Result:true <Skill {} {\"params\"=>{:name=>\"Jacob\"}} {\"pipetree\"=>[>operation.new]}> >} }
-    # it { Create.({ name: "Jacob" }, { policy: Object }).inspect.must_equal %{<Result:true <Skill {} {:policy=>Object, \"params\"=>{:name=>\"Jacob\"}} {\"pipetree\"=>[>operation.new]}> >} }
+  # it { Create.({}).inspect.must_equal %{<Result:true <Skill {} {\"params\"=>{}} {\"pipetree\"=>[>operation.new]}> >} }
+  # it { Create.(name: "Jacob").inspect.must_equal %{<Result:true <Skill {} {\"params\"=>{:name=>\"Jacob\"}} {\"pipetree\"=>[>operation.new]}> >} }
+  # it { Create.({ name: "Jacob" }, { policy: Object }).inspect.must_equal %{<Result:true <Skill {} {:policy=>Object, \"params\"=>{:name=>\"Jacob\"}} {\"pipetree\"=>[>operation.new]}> >} }
 
-    #---
-    # success?
-    class Update < Trailblazer::Operation
-      step ->(options, **) { options[:result] }
-    end
+  #---
+  # success?
+  class Update < Trailblazer::Operation
+    step ->(ctx, **) { ctx[:result] }
+  end
 
-    # operation success
-    it do
-      result = Update.(result: true)
+  # operation success
+  it do
+    result = Update.(result: true)
 
-      result.success?.must_equal true
+    result.success?.must_equal true
 
-      result.event.must_be_instance_of Trailblazer::Operation::Railway::End::Success
-      result.event.must_equal Update.outputs[:success].signal
-    end
+    result.event.must_be_instance_of Trailblazer::Operation::Railway::End::Success
+    result.event.must_equal Update.to_h[:outputs][0].signal
+  end
+
+  # operation failure
+  it do
+    result = Update.(result: false)
 
-    # operation failure
-    it do
-      result = Update.(result: false)
+    result.success?.must_equal false
+    result.failure?.must_equal true
+
+    result.event.must_be_instance_of Trailblazer::Operation::Railway::End::Failure
+    result.event.must_equal Update.to_h[:outputs].find { |output| output.semantic == :failure }.signal
+  end
 
-      result.success?.must_equal false
-      result.failure?.must_equal true
+  it "invokes with the taskWrap" do
+    operation = Class.new(Trailblazer::Operation) do
+      include Trailblazer::Activity::Testing.def_steps(:a)
 
-      result.event.must_be_instance_of Trailblazer::Operation::Railway::End::Failure
-      result.event.must_equal Update.outputs[:failure].signal
+      def self.add_1(wrap_ctx, original_args)
+        ctx, = original_args[0]
+        ctx[:seq] << 1
+        return wrap_ctx, original_args # yay to mutable state. not.
+      end
+
+      merge = [
+        [Trailblazer::Activity::TaskWrap::Pipeline.method(:insert_before), "task_wrap.call_task", ["user.add_1", method(:add_1)]]
+      ]
+
+      step :a, extensions: [Trailblazer::Activity::TaskWrap::Extension(merge: merge)]
     end
 
+    # normal operation invocation
+    result = operation.(seq: [])
+
+    result.inspect(:seq).must_equal %{<Result:true [[1, :a]] >}
+
+    # with tracing
+    result = operation.trace(seq: [])
+
+    result.inspect(:seq).must_equal %{<Result:true [[1, :a]] >}
+
+    result.wtf?
   end
 end
-

data/test/callable_test.rb

@@ -1,147 +1,147 @@
-require "test_helper"
-
-class CallableHelper < Minitest::Spec
-  Operation = Trailblazer::Operation
-  Activity  = Trailblazer::Activity
-
-  module Blog
-    Read    = ->((options, *args), *) { options["Read"] = 1; [ Activity::Right, [options, *args] ] }
-    Next    = ->((options, *args), *) { options["NextPage"] = []; [ options["return"], [options, *args] ] }
-    Comment = ->((options, *args), *) { options["Comment"] = 2; [ Activity::Right, [options, *args] ] }
-  end
-
-  module User
-    Relax   = ->((options, *args), *) { options["Relax"]=true; [ Activity::Right, [options, *args] ] }
-  end
-
-  ### Callable( )
-  ###
-  describe "circuit with 1 level of nesting" do # TODO: test this kind of configuration in dsl_tests somewhere.
-    let(:blog) do
-      Module.new do
-        extend Activity::Path()
-
-        task task: Blog::Read
-        task task: Blog::Next, Output(Activity::Right, :done) => "End.success", Output(Activity::Left, :success) => Track(:success)
-        task task: Blog::Comment
-      end
-    end
-
-    let(:user) do
-      _blog = blog
-
-      Module.new do
-        extend Activity::Path()
-
-        task task: _blog, _blog.outputs[:success] => Track(:success)
-        task task: User::Relax
-      end
-    end
-
-    it "ends before comment, on next_page" do
-      user.( [options = { "return" => Activity::Right }] ).must_equal(
-        [user.outputs[:success].signal, [{"return"=>Trailblazer::Activity::Right, "Read"=>1, "NextPage"=>[], "Relax"=>true}]]
-      )
-
-      options.must_equal({"return"=>Trailblazer::Activity::Right, "Read"=>1, "NextPage"=>[], "Relax"=>true})
-    end
-  end
-
-  ### Callable( End1, End2 )
-  ###
-  describe "circuit with 2 end events in the nested process" do
-    let(:blog) do
-      Module.new do
-        extend Activity::Path()
-
-        task task: Blog::Read
-        task task: Blog::Next, Output(Activity::Right, :success___) => :__success, Output(Activity::Left, :retry___) => _retry=End(:retry)
-      end
-    end
-
-    let(:user) do
-      _blog = blog
-
-      Module.new do
-        extend Activity::Path()
-
-        task task: _blog, _blog.outputs[:success] => Track(:success), _blog.outputs[:retry] => "End.success"
-        task task: User::Relax
-      end
-    end
-
-    it "runs from Callable->default to Relax" do
-      user.( [ options = { "return" => Activity::Right } ] ).must_equal [
-        user.outputs[:success].signal,
-        [ {"return"=>Activity::Right, "Read"=>1, "NextPage"=>[], "Relax"=>true} ]
-      ]
-
-      options.must_equal({"return"=>Activity::Right, "Read"=>1, "NextPage"=>[], "Relax"=>true})
-    end
-
-    it "runs from other Callable end" do
-      user.( [ options = { "return" => Activity::Left } ] ).must_equal [
-        user.outputs[:success].signal,
-        [ {"return"=>Activity::Left, "Read"=>1, "NextPage"=>[]} ]
-      ]
-
-      options.must_equal({"return"=>Activity::Left, "Read"=>1, "NextPage"=>[]})
-    end
-
-    #---
-    #- Callable( activity, start_at )
-    let(:with_nested_and_start_at) do
-      _blog = blog
-
-      Module.new do
-        extend Activity::Path()
-
-        task task: Operation::Callable( _blog, start_task: Blog::Next ), _blog.outputs[:success] => Track(:success)
-        task task: User::Relax
-      end
-    end
-
-    it "runs Callable from alternative start" do
-      with_nested_and_start_at.( [options = { "return" => Activity::Right }] ).
-        must_equal [
-          with_nested_and_start_at.outputs[:success].signal,
-          [ {"return"=>Activity::Right, "NextPage"=>[], "Relax"=>true} ]
-        ]
-
-      options.must_equal({"return"=>Activity::Right, "NextPage"=>[], "Relax"=>true})
-    end
-
-    #---
-    #- Callable(  activity, call: :__call__ ) { ... }
-    describe "Callable with :call option" do
-      let(:process) do
-        class Workout
-          def self.__call__((options, *args), *)
-            options[:workout]   = 9
-
-            return Activity::Right, [options, *args]
-          end
-        end
-
-        subprocess = Operation::Callable( Workout, call: :__call__ )
-
-        Module.new do
-        extend Activity::Path()
-
-          task task: subprocess
-          task task: User::Relax
-        end
-      end
-
-      it "runs Callable process with __call__" do
-        process.( [options = { "return" => Activity::Right }] ).
-          must_equal [
-            process.outputs[:success].signal,
-            [{"return"=>Activity::Right, :workout=>9, "Relax"=>true}]
-          ]
-
-        options.must_equal({"return"=>Activity::Right, :workout=>9, "Relax"=>true})
-      end
-    end
-  end
-end
+# require "test_helper"
+
+# class CallableHelper < Minitest::Spec
+#   Operation = Trailblazer::Operation
+#   Activity  = Trailblazer::Activity
+
+#   module Blog
+#     Read    = ->((options, *args), *) { options["Read"] = 1; [ Activity::Right, [options, *args] ] }
+#     Next    = ->((options, *args), *) { options["NextPage"] = []; [ options["return"], [options, *args] ] }
+#     Comment = ->((options, *args), *) { options["Comment"] = 2; [ Activity::Right, [options, *args] ] }
+#   end
+
+#   module User
+#     Relax   = ->((options, *args), *) { options["Relax"]=true; [ Activity::Right, [options, *args] ] }
+#   end
+
+#   ### Callable( )
+#   ###
+#   describe "circuit with 1 level of nesting" do # TODO: test this kind of configuration in dsl_tests somewhere.
+#     let(:blog) do
+#       Module.new do
+#         extend Activity::Path()
+
+#         task task: Blog::Read
+#         task task: Blog::Next, Output(Activity::Right, :done) => "End.success", Output(Activity::Left, :success) => Track(:success)
+#         task task: Blog::Comment
+#       end
+#     end
+
+#     let(:user) do
+#       _blog = blog
+
+#       Module.new do
+#         extend Activity::Path()
+
+#         task task: _blog, _blog.outputs[:success] => Track(:success)
+#         task task: User::Relax
+#       end
+#     end
+
+#     it "ends before comment, on next_page" do
+#       user.( [options = { "return" => Activity::Right }] ).must_equal(
+#         [user.outputs[:success].signal, [{"return"=>Trailblazer::Activity::Right, "Read"=>1, "NextPage"=>[], "Relax"=>true}]]
+#       )
+
+#       options.must_equal({"return"=>Trailblazer::Activity::Right, "Read"=>1, "NextPage"=>[], "Relax"=>true})
+#     end
+#   end
+
+#   ### Callable( End1, End2 )
+#   ###
+#   describe "circuit with 2 end events in the nested process" do
+#     let(:blog) do
+#       Module.new do
+#         extend Activity::Path()
+
+#         task task: Blog::Read
+#         task task: Blog::Next, Output(Activity::Right, :success___) => :__success, Output(Activity::Left, :retry___) => _retry=End(:retry)
+#       end
+#     end
+
+#     let(:user) do
+#       _blog = blog
+
+#       Module.new do
+#         extend Activity::Path()
+
+#         task task: _blog, _blog.outputs[:success] => Track(:success), _blog.outputs[:retry] => "End.success"
+#         task task: User::Relax
+#       end
+#     end
+
+#     it "runs from Callable->default to Relax" do
+#       user.( [ options = { "return" => Activity::Right } ] ).must_equal [
+#         user.outputs[:success].signal,
+#         [ {"return"=>Activity::Right, "Read"=>1, "NextPage"=>[], "Relax"=>true} ]
+#       ]
+
+#       options.must_equal({"return"=>Activity::Right, "Read"=>1, "NextPage"=>[], "Relax"=>true})
+#     end
+
+#     it "runs from other Callable end" do
+#       user.( [ options = { "return" => Activity::Left } ] ).must_equal [
+#         user.outputs[:success].signal,
+#         [ {"return"=>Activity::Left, "Read"=>1, "NextPage"=>[]} ]
+#       ]
+
+#       options.must_equal({"return"=>Activity::Left, "Read"=>1, "NextPage"=>[]})
+#     end
+
+#     #---
+#     #- Callable( activity, start_at )
+#     let(:with_nested_and_start_at) do
+#       _blog = blog
+
+#       Module.new do
+#         extend Activity::Path()
+
+#         task task: Operation::Callable( _blog, start_task: Blog::Next ), _blog.outputs[:success] => Track(:success)
+#         task task: User::Relax
+#       end
+#     end
+
+#     it "runs Callable from alternative start" do
+#       with_nested_and_start_at.( [options = { "return" => Activity::Right }] ).
+#         must_equal [
+#           with_nested_and_start_at.outputs[:success].signal,
+#           [ {"return"=>Activity::Right, "NextPage"=>[], "Relax"=>true} ]
+#         ]
+
+#       options.must_equal({"return"=>Activity::Right, "NextPage"=>[], "Relax"=>true})
+#     end
+
+#     #---
+#     #- Callable(  activity, call: :__call__ ) { ... }
+#     describe "Callable with :call option" do
+#       let(:process) do
+#         class Workout
+#           def self.__call__((options, *args), *)
+#             options[:workout]   = 9
+
+#             return Activity::Right, [options, *args]
+#           end
+#         end
+
+#         subprocess = Operation::Callable( Workout, call: :__call__ )
+
+#         Module.new do
+#         extend Activity::Path()
+
+#           task task: subprocess
+#           task task: User::Relax
+#         end
+#       end
+
+#       it "runs Callable process with __call__" do
+#         process.( [options = { "return" => Activity::Right }] ).
+#           must_equal [
+#             process.outputs[:success].signal,
+#             [{"return"=>Activity::Right, :workout=>9, "Relax"=>true}]
+#           ]
+
+#         options.must_equal({"return"=>Activity::Right, :workout=>9, "Relax"=>true})
+#       end
+#     end
+#   end
+# end