trailblazer 2.0.7 → 2.1.0.beta1

data/lib/trailblazer/operation/persist.rb

@@ -2,9 +2,11 @@ class Trailblazer::Operation
   module Contract
     def self.Persist(method: :save, name: "default")
       path = "contract.#{name}"
-      step = ->(input, options) { options[path].send(method) }
+      step = ->(options, **) { options[path].send(method) }
 
-      [ step, name: "persist.save" ]
+      task = Railway::TaskBuilder.( step )
+
+      { task: task, id: "persist.save" }
     end
   end
 end

data/lib/trailblazer/operation/policy.rb

@@ -8,15 +8,19 @@ class Trailblazer::Operation
         @path = path
       end
 
-      def call(input, options)
-        condition = options[@path] # this allows dependency injection.
-        result    = condition.(input, options)
+      # incoming low-level {Task API}.
+      # outgoing Task::Binary API.
+      def call((options, flow_options), **circuit_options)
+        condition = options[ @path ] # this allows dependency injection.
+        result    = condition.( [options, flow_options], **circuit_options )
 
         options["policy.#{@name}"]        = result["policy"] # assign the policy as a skill.
         options["result.policy.#{@name}"] = result
 
         # flow control
-        result.success? # since we & this, it's only executed OnRight and the return boolean decides the direction, input is passed straight through.
+        signal = result.success? ? Trailblazer::Activity::Right : Trailblazer::Activity::Left # since we & this, it's only executed OnRight and the return boolean decides the direction, input is passed straight through.
+
+        return signal, [ options, flow_options ]
       end
     end
 
@@ -26,10 +30,15 @@ class Trailblazer::Operation
       name = options[:name]
       path = "policy.#{name}.eval"
 
-      step = Eval.new( name: name, path: path )
-      step = Pipetree::Step.new(step, path => condition)
+      task = Eval.new( name: name, path: path )
+
+      runner_options = {
+        merge: Trailblazer::Operation::Wrap::Inject::Defaults(
+          path => condition
+        )
+      }
 
-      [ step, name: path ]
+      { task: task, id: path, runner_options: runner_options }
     end
   end
 end

data/lib/trailblazer/operation/pundit.rb

@@ -1,7 +1,7 @@
 class Trailblazer::Operation
   module Policy
     def self.Pundit(policy_class, action, name: :default)
-      Policy.step(Pundit.build(policy_class, action), name: name)
+      Policy.step( Pundit.build(policy_class, action), name: name )
     end
 
     module Pundit
@@ -16,14 +16,14 @@ class Trailblazer::Operation
         end
 
         # Instantiate the actual policy object, and call it.
-        def call(input, options)
+        def call((options), *)
           policy = build_policy(options)          # this translates to Pundit interface.
           result!(policy.send(@action), policy)
         end
 
       private
         def build_policy(options)
-          @policy_class.new(options["current_user"], options["model"])
+          @policy_class.new(options[:current_user], options[:model])
         end
 
         def result!(success, policy)

data/lib/trailblazer/operation/representer.rb

@@ -12,6 +12,11 @@ class Trailblazer::Operation
     end
 
     module DSL
+      def self.extended(extender)
+        extender.extend(ClassDependencies)
+        warn "[Trailblazer] Using `representer do...end` is deprecated. Please use a dedicated representer class."
+      end
+
       def representer(name=:default, constant=nil, &block)
         heritage.record(:representer, name, constant, &block)
 

data/lib/trailblazer/operation/rescue.rb

@@ -1,21 +1,24 @@
 class Trailblazer::Operation
-  def self.Rescue(*exceptions, handler: lambda { |*| }, &block)
+  NoopHandler = lambda { |*| }
+
+  def self.Rescue(*exceptions, handler: NoopHandler, &block)
     exceptions = [StandardError] unless exceptions.any?
-    handler    = Option.(handler)
+    handler    = Trailblazer::Option(handler)
 
-    rescue_block = ->(options, operation, *, &nested_pipe) {
+    # This block is evaluated by {Wrap} which currently expects a binary return type.
+    rescue_block = ->(options, flow_options, **circuit_options, &nested_activity) {
       begin
-        res = nested_pipe.call
-        res.first == ::Pipetree::Railway::Right # FIXME.
+        nested_activity.call
       rescue *exceptions => exception
-        handler.call(operation, exception, options)
+        # DISCUSS: should we deprecate this signature and rather apply the Task API here?
+        handler.call(exception, options, **circuit_options) # FIXME: when there's an error here, it shows the wrong exception!
         false
       end
     }
 
-    step, _ = Wrap(rescue_block, &block)
-
-    [ step, name: "Rescue:#{block.source_location.last}" ]
+    Wrap(rescue_block, id: "Rescue(#{rand(100)})", &block)
+    # FIXME: name
+    # [ step, name: "Rescue:#{block.source_location.last}" ]
   end
 end
 

data/lib/trailblazer/operation/validate.rb

@@ -1,58 +1,65 @@
 class Trailblazer::Operation
   module Contract
-    Railway = Pipetree::Railway
-
     # result.contract = {..}
     # result.contract.errors = {..}
     # Deviate to left track if optional key is not found in params.
     # Deviate to left if validation result falsey.
-    def self.Validate(skip_extract:false, name: "default", representer:false, key: nil) # DISCUSS: should we introduce something like Validate::Deserializer?
+    def self.Validate(skip_extract: false, name: "default", representer: false, key: nil) # DISCUSS: should we introduce something like Validate::Deserializer?
       params_path = "contract.#{name}.params" # extract_params! save extracted params here.
 
-      return Validate::Call(name: name, representer: representer, params_path: params_path) if skip_extract || representer
+      extract  = Validate::Extract.new( key: key, params_path: params_path ).freeze
+      validate = Validate.new( name: name, representer: representer, params_path: params_path ).freeze
 
-      extract_step,  extract_options  = Validate::Extract(key: key, params_path: params_path)
-      validate_step, validate_options = Validate::Call(name: name, representer: representer, params_path: params_path)
+      # Return the Validate::Call task if the first step, the params extraction, is not desired.
+      if skip_extract || representer
+        return { task: Trailblazer::Activity::Task::Binary( validate ), id: "contract.#{name}.call" }
+      end
 
-      pipe = Railway.new # TODO: make nested pipes simpler.
-        .add(Railway::Right, Railway.&(extract_step),  extract_options)
-        .add(Railway::Right, Railway.&(validate_step), validate_options)
 
-      step = ->(input, options) { pipe.(input, options).first <= Railway::Right }
+      # Build a simple Railway {Activity} for the internal flow.
+      activity = Trailblazer::Activity::Railway.build do # FIXME: make Activity.build(builder: Railway) do end an <Activity>
+        step Trailblazer::Activity::Task::Binary( extract ),  id: "#{params_path}_extract"
+        step Trailblazer::Activity::Task::Binary( validate ), id: "contract.#{name}.call"
+      end
 
-      [step, name: "contract.#{name}.validate"]
+      # DISCUSS: use Nested here?
+      # Nested.operation_class.Nested( activity, id: "contract.#{name}.validate" )
+      { task: activity, id: "contract.#{name}.validate", plus_poles: Trailblazer::Activity::Magnetic::DSL::PlusPoles.from_outputs(activity.outputs) }
     end
 
-    module Validate
-      # Macro: extract the contract's input from params by reading `:key`.
-      def self.Extract(key:nil, params_path:nil)
-        # TODO: introduce nested pipes and pass composed input instead.
-        step = ->(input, options) do
-          options[params_path] = key ? options["params"][key] : options["params"]
+    class Validate
+      # Task: extract the contract's input from params by reading `:key`.
+      class Extract
+        def initialize(key:nil, params_path:nil)
+          @key, @params_path = key, params_path
         end
 
-        [ step, name: params_path ]
+        def call( (options, flow_options), **circuit_options )
+          options[@params_path] = @key ? options[:params][@key] : options[:params]
+        end
       end
 
-      # Macro: Validates contract `:name`.
-      def self.Call(name:"default", representer:false, params_path:nil)
-        step = ->(input, options) {
-          validate!(options, name: name, representer: options["representer.#{name}.class"], params_path: params_path)
-        }
-
-        step = Pipetree::Step.new( step, "representer.#{name}.class" => representer )
+      def initialize(name:"default", representer:false, params_path:nil)
+        @name, @representer, @params_path = name, representer, params_path
+      end
 
-        [ step, name: "contract.#{name}.call" ]
+      # Task: Validates contract `:name`.
+      def call( (options, flow_options), **circuit_options )
+        validate!(
+          options,
+          representer: options["representer.#{@name}.class"] ||= @representer, # FIXME: maybe @representer should use DI.
+          params_path: @params_path
+        )
       end
 
-      def self.validate!(options, name:nil, representer:false, from: "document", params_path:nil)
-        path     = "contract.#{name}"
+      def validate!(options, representer:false, from: :document, params_path:nil)
+        path     = "contract.#{@name}"
         contract = options[path]
 
         # this is for 1.1-style compatibility and should be removed once we have Deserializer in place:
         options["result.#{path}"] = result =
           if representer
-            # use "document" as the body and let the representer deserialize to the contract.
+            # use :document as the body and let the representer deserialize to the contract.
             # this will be simplified once we have Deserializer.
             # translates to contract.("{document: bla}") { MyRepresenter.new(contract).from_json .. }
             contract.(options[from]) { |document| representer.new(contract).parse(document) }

data/lib/trailblazer/operation/wrap.rb

@@ -1,22 +1,60 @@
 class Trailblazer::Operation
-  Base = self # TODO: we won't need this with 2.1.
 
-  def self.Wrap(wrap, &block)
-    operation = Class.new(Base)
-    # DISCUSS: don't instance_exec when |pipe| given?
-    operation.instance_exec(&block) # evaluate the nested pipe.
+  # false is automatically connected to End.failure.
 
-    pipe = operation["pipetree"]
-    pipe.add(nil, nil, {delete: "operation.new"}) # TODO: make this a bit more elegant.
+  def self.Wrap(user_wrap, id: "Wrap/#{rand(100)}", &block)
+    operation_class = Wrap.Operation(block)
+    wrapped         = Wrap::Wrapped.new(operation_class, user_wrap)
 
-    step = Wrap.for(wrap, pipe)
+    # connect `false` as an end event, when an exception stopped the wrap, for example.
 
-    [ step, {} ]
+    { task: wrapped, id: id, plus_poles: Trailblazer::Activity::Magnetic::DSL::PlusPoles.from_outputs(operation_class.outputs) }
+    # TODO: Nested could have a better API and do the "merge" for us!
   end
 
   module Wrap
-    def self.for(wrap, pipe)
-      ->(input, options) { wrap.(options, input, pipe, & ->{ pipe.(input, options) }) }
+    def self.Operation(block)
+      Class.new( Nested.operation_class, &block ) # Usually resolves to Trailblazer::Operation.
+    end
+
+    # behaves like an operation so it plays with Nested and simply calls the operation in the user-provided block.
+    class Wrapped #< Trailblazer::Operation # FIXME: the inheritance is only to satisfy Nested( Wrapped.new )
+      include Trailblazer::Activity::Interface
+
+      def initialize(operation, user_wrap)
+        @operation  = operation
+        @user_wrap  = user_wrap
+      end
+
+      def call( (options, flow_options), **circuit_options )
+        block_calling_wrapped = -> {
+          args, circuit_options_with_wrap_static = Railway::TaskWrap.arguments_for_call( @operation, [options, flow_options], **circuit_options )
+
+          # TODO: this is not so nice, still working out how to separate all those bits and pieces.
+          @operation.instance_variable_get(:@process).( args, **circuit_options.merge(circuit_options_with_wrap_static) ) # FIXME: arguments_for_call don't return the full circuit_options, :exec_context gets lost.
+        }
+
+        # call the user's Wrap {} block in the operation.
+        # This will invoke block_calling_wrapped above if the user block yields.
+        returned = @user_wrap.( options, flow_options, **circuit_options, &block_calling_wrapped )
+
+        # returned could be
+        #  1. the 1..>=3 Task interface result
+        #  2. false
+        #  3. true or something else, but not the Task interface (when rescue isn't needed)
+
+        # legacy outcome.
+        # FIXME: we *might* return some "older version" of options here!
+        if returned === false
+          return @operation.outputs[:failure].signal, [options, flow_options]
+        end
+
+        returned # let's hope returned is one of activity's Ends.
+      end
+
+      def outputs
+        @operation.outputs # FIXME: we don't map false, yet
+      end
     end
   end # Wrap
 end

data/lib/trailblazer/task.rb

@@ -0,0 +1,20 @@
+module Trailblazer
+  class Activity
+    module Task
+      # Convenience functions for tasks. Totally optional.
+
+      # Task::Binary aka "step"
+      # Step is binary task: true=> Right, false=>Left.
+      # Step call proc.(options, flow_options)
+      # Step is supposed to run Option::KW, so `step` should be Option::KW.
+      #
+      # Returns task to call the proc with (options, flow_options), omitting `direction`.
+      # When called, the task always returns a direction signal.
+      def self.Binary(step, on_true=Activity::Right, on_false=Activity::Left)
+        ->(*args) do # Activity/Task interface.
+          [ step.(*args) ? on_true : on_false, *args ] # <=> Activity/Task interface
+        end
+      end
+    end
+  end
+end

data/lib/trailblazer/version.rb

@@ -1,3 +1,3 @@
 module Trailblazer
-  VERSION = "2.0.7"
+  VERSION = "2.1.0.beta1"
 end

data/test/benchmark.rb

@@ -0,0 +1,63 @@
+require "test_helper"
+
+require "benchmark/ips"
+
+
+def positional_vs_decompose
+  arg = [ [1, 2], 3 ]
+
+  def a((one, two), three)
+    one + two + three
+  end
+
+  def b(arr, three)
+    arr[0] + arr[1] + three
+  end
+
+  Benchmark.ips do |x|
+    x.report("decompose") { a(*arg) }
+    x.report("positional") { b(*arg) }
+    x.compare!
+  end
+
+  #  decompose      5.646M (± 3.1%) i/s -     28.294M in   5.015759s
+  # positional      5.629M (± 8.0%) i/s -     28.069M in   5.029745s
+end
+
+# positional_vs_decompose
+
+##########################################################
+
+class Callable
+  def initialize(proc, i)
+    @proc = proc
+    @i = i
+  end
+
+  def call(args)
+    @proc.(@i, args)
+  end
+end
+
+def scoped(proc, i)
+  ->(args) { proc.(i, args) }
+end
+
+def object_vs_method_scope
+  proc = ->(i, args) { i + args }
+
+  callable = Callable.new(proc, 2)
+  scoped  = scoped(proc, 2)
+
+  Benchmark.ips do |x|
+    x.report("callable") { callable.(1) }
+    x.report("scoped")   { scoped.(1) }
+    x.compare!
+  end
+end
+
+object_vs_method_scope
+
+# Comparison:
+#             callable:  4620906.3 i/s
+#               scoped:  3388535.6 i/s - 1.36x  slower

data/test/deprecation/call_test.rb

@@ -0,0 +1,42 @@
+require "test_helper"
+
+require "trailblazer/deprecation/context"
+require "trailblazer/deprecation/call"
+
+class DeprecationCallTest < Minitest::Spec
+  class Create < Trailblazer::Operation
+    step :create_model
+
+    def create_model(options, params:, **)
+      options["model"] = params.inspect
+      options[:user] = options["current_user"]
+    end
+  end
+
+  it "works with correct style" do
+    result = Create.( params: { title: "Hello" } )
+    result.inspect(:model, :user, :current_user, :params).must_equal %{<Result:false ["{:title=>\\\"Hello\\\"}", nil, nil, {:title=>\"Hello\"}] >}
+  end
+
+  it "works with correct style plus dependencies" do
+    result = Create.( params: { title: "Hello" }, current_user: Object )
+    result.inspect(:model, :user, :current_user, :params).must_equal %{<Result:true ["{:title=>\\\"Hello\\\"}", Object, Object, {:title=>\"Hello\"}] >}
+  end
+
+  it "converts old positional style" do
+    result = Create.( { title: "Hello" }, "current_user" => user=Object )
+    result.inspect(:model, :user, :current_user, :params).must_equal %{<Result:true ["{:title=>\\\"Hello\\\"}", Object, Object, {:title=>\"Hello\"}] >}
+  end
+
+  class WeirdStrongParameters < Hash
+  end
+
+  it "converts old positional style with StrongParameters" do
+    params = WeirdStrongParameters.new
+    params[:title] = "Hello"
+
+    result = Create.( params, "current_user" => user=Object )
+
+    result.inspect(:model, :user, :current_user, :params).must_equal %{<Result:true ["{:title=>\\\"Hello\\\"}", Object, Object, {:title=>\"Hello\"}] >}
+  end
+end

data/test/deprecation/context_test.rb

@@ -0,0 +1,19 @@
+require "test_helper"
+
+require "trailblazer/deprecation/context"
+
+class DeprecationContextTest < Minitest::Spec
+  class Create < Trailblazer::Operation
+    step :create_model
+
+    def create_model(options, params:, **)
+      options["model"] = params.inspect
+      options[:user] = options["current_user"]
+    end
+  end
+
+  it do
+    result = Create.( "params"=> {title: "Hello"}, "current_user" => user=Object)
+    result.inspect(:model, :user, :current_user, :params).must_equal %{<Result:true ["{:title=>\\\"Hello\\\"}", Object, Object, {:title=>\"Hello\"}] >}
+  end
+end