trailblazer 2.0.0 → 2.0.1

data/lib/trailblazer/operation/nested.rb

@@ -1,43 +1,32 @@
 class Trailblazer::Operation
-  module Nested
-    # Please note that the instance_variable_get are here on purpose since the
-    # superinternal API is not entirely decided, yet.
-    def self.import!(operation, import, step)
-      import.(:&, ->(input, options) {
-        result = step._call(*options.to_runtime_data)
+  def self.Nested(step)
+    step = Nested.for(step)
 
-        result.instance_variable_get(:@data).to_mutable_data.each do |k,v|
-          options[k] = v
-        end
-
-        result.success? # DISCUSS: what if we could simply return the result object here?
-      }, {} )
-    end
+    [ step, {} ]
   end
 
-  DSL.macro!(:Nested, Nested)
+  module Nested
+    def self.proc_for(step)
+      if step.is_a?(Class) && step <= Trailblazer::Operation # interestingly, with < we get a weird nil exception. bug in Ruby?
+        proc = ->(input, options) { step._call(*options.to_runtime_data) }
+      else
+        option = Option::KW.(step)
+        proc = ->(input, options) { option.(input, options).(*options.to_runtime_data) }
+      end
+    end
 
-  module Rescue
-    def self.import!(_operation, import, *exceptions, handler:->(*){}, &block)
-      exceptions = [StandardError] unless exceptions.any?
-      handler    = Pipetree::DSL::Option.(handler)
+    # Please note that the instance_variable_get are here on purpose since the
+    # superinternal API is not entirely decided, yet.
+    def self.for(step)
+      proc = proc_for(step)
 
-      rescue_block = ->(options, operation, *, &nested_pipe) {
-        begin
-          res = nested_pipe.call
-          res.first == ::Pipetree::Flow::Right # FIXME.
-        rescue *exceptions => exception
-          handler.call(operation, exception, options)
-          #options["result.model.find"] = "argh! because #{exception.class}"
-          false
-        end
-      }
+      ->(input, options) do
+        result = proc.(input, options) # TODO: what about containers?
 
-      # operation.| operation.Wrap(rescue_block, &block), name: "Rescue:#{block.source_location.last}"
-      Wrap.import! _operation, import, rescue_block, name: "Rescue:#{block.source_location.last}", &block
+        result.instance_variable_get(:@data).to_mutable_data.each { |k,v| options[k] = v }
+        result.success? # DISCUSS: what if we could simply return the result object here?
+      end
     end
   end
-
-  DSL.macro!(:Rescue, Rescue)
 end
 

data/lib/trailblazer/operation/persist.rb

@@ -1,14 +1,10 @@
 class Trailblazer::Operation
   module Contract
-    module Persist
-      def self.import!(operation, import, method: :save, name: "default")
-        path = "contract.#{name}"
+    def self.Persist(method: :save, name: "default")
+      path = "contract.#{name}"
+      step = ->(input, options) { options[path].send(method) }
 
-        import.(:&, ->(input, options) { options[path].send(method) }, # TODO: test me.
-          name: "persist.save")
-      end
+      [ step, name: "persist.save" ]
     end
   end
-
-  DSL.macro!(:Persist, Contract::Persist, Contract.singleton_class) # Contract::Persist()
 end

data/lib/trailblazer/operation/policy.rb

@@ -3,8 +3,6 @@ class Trailblazer::Operation
     # Step: This generically `call`s a policy and then pushes its result to `options`.
     # You can use any callable object as a policy with this step.
     class Eval
-      include Uber::Callable
-
       def initialize(name:nil, path:nil)
         @name = name
         @path = path
@@ -24,22 +22,14 @@ class Trailblazer::Operation
 
     # Adds the `yield` result to the pipe and treats it like a
     # policy-compatible  object at runtime.
-    def self.add!(operation, import, options, insert_options, &block)
+    def self.step(condition, options, &block)
       name = options[:name]
-      path = options[:path]
-
-      configure!(operation, import, options, &block)
+      path = "policy.#{name}.eval"
 
-      # add step.
-      import.(:&, Eval.new( name: name, path: path ),
-        insert_options.merge(name: path)
-      )
-    end
+      step = Eval.new( name: name, path: path )
+      step = Pipetree::Step.new(step, path => condition)
 
-  private
-    def self.configure!(operation, import, options)
-      # configure class level.
-      operation[ options[:path] ] = yield
+      [ step, name: path ]
     end
   end
 end

data/lib/trailblazer/operation/pundit.rb

@@ -1,10 +1,10 @@
 class Trailblazer::Operation
   module Policy
-    module Pundit
-      def self.import!(operation, import, policy_class, action, options={}, insert_options={})
-        Policy.add!(operation, import, options, insert_options) { Pundit.build(policy_class, action) }
-      end
+    def self.Pundit(policy_class, action, name: :default)
+      Policy.step(Pundit.build(policy_class, action), name: name)
+    end
 
+    module Pundit
       def self.build(*args, &block)
         Condition.new(*args, &block)
       end
@@ -16,14 +16,14 @@ class Trailblazer::Operation
         end
 
         # Instantiate the actual policy object, and call it.
-        def call(skills)
-          policy = build_policy(skills)          # this translates to Pundit interface.
+        def call(options)
+          policy = build_policy(options)          # this translates to Pundit interface.
           result!(policy.send(@action), policy)
         end
 
       private
-        def build_policy(skills)
-          @policy_class.new(skills["current_user"], skills["model"])
+        def build_policy(options)
+          @policy_class.new(options["current_user"], options["model"])
         end
 
         def result!(success, policy)
@@ -34,14 +34,5 @@ class Trailblazer::Operation
         end
       end
     end
-
-    def self.Pundit(policy, condition, name: :default, &block)
-      options = {
-        name:  name,
-        path: "policy.#{name}.eval",
-      }
-
-      [Pundit, [policy, condition, options], block]
-    end
   end
 end

data/lib/trailblazer/operation/rescue.rb

@@ -1,25 +1,25 @@
 class Trailblazer::Operation
-  module Rescue
-    Noop = ->(*) {}
+  def self.Rescue(*exceptions, handler: Rescue::Noop, &block)
+    exceptions = [StandardError] unless exceptions.any?
+    handler    = Option.(handler)
 
-    def self.import!(_operation, import, *exceptions, handler: Noop, &block)
-      exceptions = [StandardError] unless exceptions.any?
-      handler    = Option.(handler)
+    rescue_block = ->(options, operation, *, &nested_pipe) {
+      begin
+        res = nested_pipe.call
+        res.first == ::Pipetree::Railway::Right # FIXME.
+      rescue *exceptions => exception
+        handler.call(operation, exception, options)
+        false
+      end
+    }
 
-      rescue_block = ->(options, operation, *, &nested_pipe) {
-        begin
-          res = nested_pipe.call
-          res.first == ::Pipetree::Flow::Right # FIXME.
-        rescue *exceptions => exception
-          handler.call(operation, exception, options)
-          false
-        end
-      }
+    step, _ = Wrap(rescue_block, &block)
 
-      Wrap.import! _operation, import, rescue_block, name: "Rescue:#{block.source_location.last}", &block
-    end
+    [ step, name: "Rescue:#{block.source_location.last}" ]
   end
 
-  DSL.macro!(:Rescue, Rescue)
+  module Rescue
+    Noop = ->(*) {}
+  end
 end
 

data/lib/trailblazer/operation/validate.rb

@@ -1,36 +1,51 @@
 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?
+      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_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)
+
+      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 }
+
+      [step, name: "contract.#{name}.validate"]
+    end
+
     module Validate
-      def self.import!(operation, import, skip_extract:false, name: "default", representer:false, key: nil) # DISCUSS: should we introduce something like Validate::Deserializer?
-        if representer
-          skip_extract = true
-          operation["representer.#{name}.class"] = representer
+      # 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"]
         end
 
-        params_path = "contract.#{name}.params" # extract_params! save extracted params here.
+        [ step, name: params_path ]
+      end
 
-        import.(:&, ->(input, options) { extract_params!(input, options, key: key, path: params_path) },
-          name: params_path) unless skip_extract
+      # 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)
+        }
 
-        # call the actual contract.validate(params)
-        # DISCUSS: should we pass the representer here, or do that in #validate! i'm still mulling over what's the best, most generic approach.
-        import.(:&, ->(operation, options) do
-            validate!(operation, options, name: name, representer: options["representer.#{name}.class"], key: key, params_path: params_path)
-          end,
-          name: "contract.#{name}.validate", # visible name of the pipe step.
-        )
-        end
+        step = Pipetree::Step.new( step, "representer.#{name}.class" => representer )
 
-      def self.extract_params!(operation, options, key:nil, path:nil)
-        # TODO: introduce nested pipes and pass composed input instead.
-        options[path] = key ? options["params"][key] : options["params"]
+        [ step, name: "contract.#{name}.call" ]
       end
 
-      def self.validate!(operation, options, name: nil, representer:false, from: "document", params_path:nil, **)
+      def self.validate!(options, name:nil, representer:false, from: "document", params_path:nil)
         path     = "contract.#{name}"
         contract = options[path]
 
@@ -50,6 +65,4 @@ class Trailblazer::Operation
       end
     end
   end
-
-  DSL.macro!(:Validate, Contract::Validate, Contract.singleton_class)
 end

data/lib/trailblazer/operation/wrap.rb

@@ -1,35 +1,22 @@
 class Trailblazer::Operation
-  module Wrap
-    def self.import!(operation, import, wrap, _options={}, &block)
-      pipe_api = API.new(operation, pipe = ::Pipetree::Flow.new)
-
-      # DISCUSS: don't instance_exec when |pipe| given?
-      # yield pipe_api # create the nested pipe.
-      pipe_api.instance_exec(&block) # evaluate the nested pipe. this gets written onto `pipe`.
-
-      import.(:&, ->(input, options) { wrap.(options, input, pipe, & ->{ pipe.(input, options) }) }, _options)
-    end
+  def self.Wrap(wrap, &block)
+    operation = Class.new(Trailblazer::Operation) # DISCUSS: Trailblazer::Operation.inherit(skip_operation.new: true)
+    # DISCUSS: don't instance_exec when |pipe| given?
+    operation.instance_exec(&block) # evaluate the nested pipe.
 
-    class API
-      include Pipetree::DSL
-      include Pipetree::DSL::Macros
+    pipe = operation["pipetree"]
+    pipe.add(nil, nil, {delete: "operation.new"}) # TODO: make this a bit more elegant.
 
-      def initialize(target, pipe)
-        @target, @pipe = target, pipe
-      end
+    step = Wrap.for(wrap, pipe)
 
-      def _insert(operator, proc, options={}) # TODO: test me.
-        Pipetree::DSL.insert(@pipe, operator, proc, options, definer_name: @target.name)
-      end
+    [ step, {} ]
+  end
 
-      def |(cfg, user_options={})
-        Pipetree::DSL.import(@target, @pipe, cfg, user_options)
-      end
-      alias_method :step, :| # DISCUSS: uhm...
+  module Wrap
+    def self.for(wrap, pipe)
+      ->(input, options) { wrap.(options, input, pipe, & ->{ pipe.(input, options) }) }
     end
   end # Wrap
-
-  DSL.macro!(:Wrap, Wrap)
 end
 
 # (options, *) => (options, operation, bla)

data/lib/trailblazer/version.rb

@@ -1,3 +1,3 @@
 module Trailblazer
-  VERSION = "2.0.0"
+  VERSION = "2.0.1"
 end

data/test/docs/dry_test.rb

@@ -19,10 +19,10 @@ class DryContainerTest < Minitest::Spec
   #- dependency injection
   #- with Dry-container
   class Create < Trailblazer::Operation
-    self.| Model( Song, :new )
-    self.| Contract::Build()
-    self.| Contract::Validate()
-    self.| Contract::Persist( method: :sync )
+    step Model( Song, :new )
+    step Contract::Build()
+    step Contract::Validate()
+    step Contract::Persist( method: :sync )
   end
   #:key end
 

data/test/docs/fast_test.rb

@@ -0,0 +1,164 @@
+require "test_helper"
+
+class DocsFailFastOptionTest < Minitest::Spec
+  Song = Struct.new(:id, :title) do
+    def self.find_by(id); nil end
+  end
+
+  class MyContract < Reform::Form
+  end
+
+
+  #:ffopt
+  class Update < Trailblazer::Operation
+    step    Model( Song, :find_by )
+    failure :abort!,                                fail_fast: true
+    step    Contract::Build( constant: MyContract )
+    step    Contract::Validate( )
+    failure :handle_invalid_contract!  # won't be executed if #abort! is executed.
+
+    def abort!(options, params:, **)
+      options["result.model.song"] = "Something went wrong with ID #{params[:id]}!"
+    end
+    # ..
+  end
+  #:ffopt end
+
+  it { Update.(id: 1).inspect("result.model.song", "contract.default").must_equal %{<Result:false [\"Something went wrong with ID 1!\", nil] >} }
+  it do
+  #:ffopt-res
+    result = Update.(id: 1)
+    result["result.model.song"] #=> "Something went wrong with ID 1!"
+  #:ffopt-res end
+  end
+end
+
+class DocsFailFastOptionWithStepTest < Minitest::Spec
+  Song = Class.new do
+    def self.find_by(*); Object end
+  end
+
+  #:ffopt-step
+  class Update < Trailblazer::Operation
+    step :empty_id?,             fail_fast: true
+    step Model( Song, :find_by )
+    failure :handle_empty_db!   # won't be executed if #empty_id? returns falsey.
+
+    def empty_id?(options, params:, **)
+      params[:id] # returns false if :id missing.
+    end
+  end
+  #:ffopt-step end
+
+  it { Update.({ id: nil }).inspect("model").must_equal %{<Result:false [nil] >} }
+  it { Update.({ id: 1 }).inspect("model").must_equal %{<Result:true [Object] >} }
+  it do
+  #:ffopt-step-res
+    result = Update.({ id: nil })
+
+    result.failure? #=> true
+    result["model"] #=> nil
+  #:ffopt-step-res end
+  end
+end
+
+class DocsPassFastWithStepOptionTest < Minitest::Spec
+  Song = Struct.new(:id, :title) do
+    def self.find_by(id); nil end
+  end
+
+  class MyContract < Reform::Form
+  end
+
+  #:pfopt-step
+  class Update < Trailblazer::Operation
+    step    Model( Song, :find_by )
+    failure :abort!,                                fail_fast: true
+    step    Contract::Build( constant: MyContract )
+    step    Contract::Validate( )
+    failure :handle_invalid_contract!  # won't be executed if #abort! is executed.
+
+    def abort!(options, params:, **)
+      options["result.model.song"] = "Something went wrong with ID #{params[:id]}!"
+    end
+    # ..
+  end
+  #:pfopt-step end
+
+  it { Update.(id: 1).inspect("result.model.song", "contract.default").must_equal %{<Result:false [\"Something went wrong with ID 1!\", nil] >} }
+  it do
+  #:pfopt-step-res
+    result = Update.(id: 1)
+    result["result.model.song"] #=> "Something went wrong with ID 1!"
+  #:pfopt-step-res end
+  end
+end
+
+class DocsFailFastMethodTest < Minitest::Spec
+  Song = Struct.new(:id, :title) do
+    def self.find_by(id); nil end
+  end
+
+  #:ffmeth
+  class Update < Trailblazer::Operation
+    step :filter_params!         # emits fail_fast!
+    step Model( Song, :find_by )
+    failure :handle_fail!
+
+    def filter_params!(options, params:, **)
+      unless params[:id]
+        options["result.params"] = "No ID in params!"
+        return Railway.fail_fast!
+      end
+    end
+
+    def handle_fail!(options, **)
+      options["my.status"] = "Broken!"
+    end
+  end
+  #:ffmeth end
+
+  it { Update.({}).inspect("result.params", "my.status").must_equal %{<Result:false [\"No ID in params!\", nil] >} }
+  it do
+  #:ffmeth-res
+    result = Update.(id: 1)
+    result["result.params"] #=> "No ID in params!"
+    result["my.status"]     #=> nil
+  #:ffmeth-res end
+  end
+end
+
+class DocsPassFastMethodTest < Minitest::Spec
+  Song = Struct.new(:id, :title) do
+    def save; end
+  end
+
+  class MyContract < Reform::Form
+  end
+
+  #:pfmeth
+  class Create < Trailblazer::Operation
+    step Model( Song, :new )
+    step :empty_model!                           # emits pass_fast!
+    step Contract::Build( constant: MyContract )
+    # ..
+
+    def empty_model!(options, is_empty:, model:, **)
+      return unless is_empty
+      model.save
+      Railway.pass_fast!
+    end
+  end
+  #:pfmeth end
+
+  it { Create.({ title: "Tyrant"}, "is_empty" => true).inspect("model").must_equal %{<Result:true [#<struct DocsPassFastMethodTest::Song id=nil, title=nil>] >} }
+  it do
+  #:pfmeth-res
+    result = Create.({}, "is_empty" => true)
+    result["model"] #=> #<Song id=nil, title=nil>
+  #:pfmeth-res end
+  end
+end
+
+# fail!
+# pass!