trailblazer 1.1.2 → 2.0.0.beta1

data/test/docs/rescue_test.rb

@@ -0,0 +1,153 @@
+require "test_helper"
+
+class NestedRescueTest < Minitest::Spec
+  #---
+  # nested raise (i hope people won't use this but it works)
+  A = Class.new(RuntimeError)
+  Y = Class.new(RuntimeError)
+
+  class NestedInsanity < Trailblazer::Operation
+    step Rescue {
+      step ->(options) { options["a"] = true }
+      step Rescue {
+        step ->(options) { options["y"] = true }
+        step ->(options) { raise Y if options["raise-y"] }
+        step ->(options) { options["z"] = true }
+      }
+      step ->(options) { options["b"] = true }
+      step ->(options) { raise A if options["raise-a"] }
+      step ->(options) { options["c"] = true }
+      self.< ->(options) { options["inner-err"] = true }
+    }
+    step ->(options) { options["e"] = true }
+    self.< ->(options) { options["outer-err"] = true }
+  end
+
+  it { NestedInsanity["pipetree"].inspect.must_equal %{[>>operation.new,&Rescue:10,>:22,<NestedRescueTest::NestedInsanity:23]} }
+  it { NestedInsanity.({}).inspect("a", "y", "z", "b", "c", "e", "inner-err", "outer-err").must_equal %{<Result:true [true, true, true, true, true, true, nil, nil] >} }
+  it { NestedInsanity.({}, "raise-y" => true).inspect("a", "y", "z", "b", "c", "e", "inner-err", "outer-err").must_equal %{<Result:false [true, true, nil, nil, nil, nil, true, true] >} }
+  it { NestedInsanity.({}, "raise-a" => true).inspect("a", "y", "z", "b", "c", "e", "inner-err", "outer-err").must_equal %{<Result:false [true, true, true, true, nil, nil, nil, true] >} }
+
+  #-
+  # inheritance
+  class UbernestedInsanity < NestedInsanity
+  end
+
+  it { UbernestedInsanity.({}).inspect("a", "y", "z", "b", "c", "e", "inner-err", "outer-err").must_equal %{<Result:true [true, true, true, true, true, true, nil, nil] >} }
+  it { UbernestedInsanity.({}, "raise-a" => true).inspect("a", "y", "z", "b", "c", "e", "inner-err", "outer-err").must_equal %{<Result:false [true, true, true, true, nil, nil, nil, true] >} }
+end
+
+class RescueTest < Minitest::Spec
+  RecordNotFound = Class.new(RuntimeError)
+
+  Song = Struct.new(:id, :title) do
+    def self.find(id)
+      raise if id == "RuntimeError!"
+      id.nil? ? raise(RecordNotFound) : new(id)
+    end
+
+    def lock!
+    end
+  end
+
+  #:simple
+  class Create < Trailblazer::Operation
+    class MyContract < Reform::Form
+      property :title
+    end
+
+    step Rescue {
+      step Model(Song, :find)
+      step Contract::Build( constant: MyContract )
+    }
+    step Contract::Validate()
+    step Persist( method: :sync )
+  end
+  #:simple end
+
+  it { Create.( id: 1, title: "Prodigal Son" )["contract.default"].model.inspect.must_equal %{#<struct RescueTest::Song id=1, title="Prodigal Son">} }
+  it { Create.( id: nil ).inspect("model").must_equal %{<Result:false [nil] >} }
+
+  #-
+  # Rescue ExceptionClass, handler: ->(*) { }
+  class WithExceptionNameTest < Minitest::Spec
+  #
+  class MyContract < Reform::Form
+    property :title
+  end
+  #:name
+  class Create < Trailblazer::Operation
+    step Rescue( RecordNotFound, KeyError, handler: :rollback! ) {
+      step Model( Song, :find )
+      step Contract::Build( constant: MyContract )
+    }
+    step Contract::Validate()
+    step Persist( method: :sync )
+
+    def rollback!(exception, options)
+      options["x"] = exception.class
+    end
+  end
+  #:name end
+
+    it { Create.( id: 1, title: "Prodigal Son" )["contract.default"].model.inspect.must_equal %{#<struct RescueTest::Song id=1, title="Prodigal Son">} }
+    it { Create.( id: 1, title: "Prodigal Son" ).inspect("x").must_equal %{<Result:true [nil] >} }
+    it { Create.( id: nil ).inspect("model", "x").must_equal %{<Result:false [nil, RescueTest::RecordNotFound] >} }
+    it { assert_raises(RuntimeError) { Create.( id: "RuntimeError!" ) } }
+  end
+
+
+  #-
+  # cdennl use-case
+  class CdennlRescueAndTransactionTest < Minitest::Spec
+    module Sequel
+      cattr_accessor :result
+
+      def self.transaction
+        yield.tap do |res|
+          self.result = res
+        end
+      end
+    end
+
+  #:example
+  class Create < Trailblazer::Operation
+    class MyContract < Reform::Form
+      property :title
+    end
+
+    step Rescue( RecordNotFound, handler: :rollback! ) {
+      step Wrap ->(*, &block) { Sequel.transaction do block.call end } {
+        step Model( Song, :find )
+        step ->(options) { options["model"].lock! } # lock the model.
+        step Contract::Build( constant: MyContract )
+        step Contract::Validate( )
+        step Persist( method: :sync )
+      }
+    }
+    failure :error! # handle all kinds of errors.
+
+    def rollback!(exception, options)
+      #~ex
+      options["x"] = exception.class
+      #~ex end
+    end
+
+    def error!(options)
+      #~ex
+      options["err"] = true
+      #~ex end
+    end
+  end
+  #:example end
+
+    it { Create.( id: 1, title: "Pie" ).inspect("model", "x", "err").must_equal %{<Result:true [#<struct RescueTest::Song id=1, title=\"Pie\">, nil, nil] >} }
+    # raise exceptions in Model:
+    it { Create.( id: nil ).inspect("model", "x").must_equal %{<Result:false [nil, RescueTest::RecordNotFound] >} }
+    it { assert_raises(RuntimeError) { Create.( id: "RuntimeError!" ) } }
+    it do
+      Create.( id: 1, title: "Pie" )
+      Sequel.result.first.must_equal Pipetree::Flow::Right
+    end
+  end
+end

data/test/docs/wrap_test.rb

@@ -0,0 +1,174 @@
+require "test_helper"
+
+class WrapTest < Minitest::Spec
+  Song = Struct.new(:id, :title) do
+    def self.find(id)
+      id.nil? ? raise : new(id)
+    end
+  end
+
+  class Create < Trailblazer::Operation
+    class MyContract < Reform::Form
+      property :title
+    end
+
+    step Wrap ->(options, *, &block) {
+      begin
+        block.call
+      rescue => exception
+        options["result.model.find"] = "argh! because #{exception.class}"
+        false
+      end } {
+      step Model( Song, :find )
+      step Contract::Build( constant: MyContract )
+    }
+    step Contract::Validate()
+    step Persist( method: :sync )
+  end
+
+  it { Create.( id: 1, title: "Prodigal Son" )["contract.default"].model.inspect.must_equal %{#<struct WrapTest::Song id=1, title="Prodigal Son">} }
+  it { Create.( id: nil ).inspect("result.model.find").must_equal %{<Result:false [\"argh! because RuntimeError\"] >} }
+
+  #-
+  # Wrap return
+  class WrapReturnTest < Minitest::Spec
+    class Create < Trailblazer::Operation
+      step Wrap ->(options, *, &block) { options["yield?"] ? block.call : false } {
+        step ->(options) { options["x"] = true }
+        step :noop!
+        # ...
+      }
+
+      def noop!(options)
+      end
+    end
+
+    it { Create.().inspect("x").must_equal %{<Result:false [nil] >} }
+    # returns falsey means deviate to left.
+    it { Create.({}, "yield?" => true).inspect("x").must_equal %{<Result:true [true] >} }
+  end
+
+  class WrapWithCallableTest < Minitest::Spec
+    class MyWrapper
+      extend Uber::Callable
+
+      def self.call(options, *, &block)
+        options["yield?"] ? yield : false
+      end
+    end
+
+    class Create < Trailblazer::Operation
+      step Wrap( MyWrapper ) {
+        step ->(options) { options["x"] = true }
+        # ...
+      }
+    end
+
+    it { Create.().inspect("x").must_equal %{<Result:false [nil] >} }
+    # returns falsey means deviate to left.
+    it { Create.({}, "yield?" => true).inspect("x").must_equal %{<Result:true [true] >} }
+  end
+
+  #-
+  # arguments for Wrap
+  class Update < Trailblazer::Operation
+    step Wrap ->(options, operation, pipe, &block) { operation["yield?"] ? block.call : false } {
+      step ->(options) { options["x"] = true }
+    }
+  end
+
+  it { Update.().inspect("x").must_equal %{<Result:false [nil] >} }
+  it { Update.({}, "yield?" => true).inspect("x").must_equal %{<Result:true [true] >} }
+
+  class WrapExampleProcTest < Minitest::Spec
+    module Sequel
+      def self.transaction
+        yield
+      end
+    end
+
+  #:sequel-transaction
+  class Create < Trailblazer::Operation
+    #~wrap-only
+    class MyContract < Reform::Form
+      property :title
+    end
+
+    #~wrap-only end
+    step Wrap ->(*, &block) { Sequel.transaction do block.call end } {
+      step Model( Song, :new )
+      #~wrap-only
+      step Contract::Build( constant: MyContract )
+      step Contract::Validate( )
+      step Persist( method: :sync )
+      #~wrap-only end
+    }
+    failure :error! # handle all kinds of errors.
+    #~wrap-only
+    step :notify!
+
+    def error!(options)
+      # handle errors after the wrap
+    end
+
+    def notify!(options)
+      # send emails, because success...
+    end
+    #~wrap-only end
+  end
+  #:sequel-transaction end
+
+    it { Create.( title: "Pie" ).inspect("model", "x", "err").must_equal %{<Result:true [#<struct WrapTest::Song id=nil, title=\"Pie\">, nil, nil] >} }
+  end
+
+  class WrapExampleCallableTest < Minitest::Spec
+    module Sequel
+      def self.transaction
+        yield
+      end
+    end
+
+  #:callable-t
+  class MyTransaction
+    extend Uber::Callable
+
+    def self.call(options, *)
+      Sequel.transaction { yield } # yield runs the nested pipe.
+    end
+  end
+  #:callable-t end
+  #:sequel-transaction-callable
+  class Create < Trailblazer::Operation
+    #~wrap-onlyy
+    class MyContract < Reform::Form
+      property :title
+    end
+
+    #~wrap-onlyy end
+    step Wrap( MyTransaction ) {
+      step Model( Song, :new )
+      #~wrap-onlyy
+      step Contract::Build( constant: MyContract )
+      step Contract::Validate( )
+      step Persist( method: :sync )
+      #~wrap-onlyy end
+    }
+    failure :error! # handle all kinds of errors.
+    #~wrap-onlyy
+    step :notify!
+
+    def error!(options)
+      # handle errors after the wrap
+    end
+
+    def notify!(options)
+      # send emails, because success...
+    end
+    #~wrap-onlyy end
+  end
+  #:sequel-transaction-callable end
+
+    it { Create.( title: "Pie" ).inspect("model", "x", "err").must_equal %{<Result:true [#<struct WrapTest::Song id=nil, title=\"Pie\">, nil, nil] >} }
+  end
+end
+

data/test/gemfiles/Gemfile.ruby-1.9

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+gemspec path: "../../"
+

data/test/gemfiles/Gemfile.ruby-2.0

@@ -0,0 +1,12 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in trailblazer.gemspec
+gemspec path: "../../"
+
+gem "multi_json"
+gem "trailblazer-operation"
+gem "minitest-line"
+gem "benchmark-ips"
+gem "activesupport", "~> 4.2.0"
+gem "reform-rails"
+gem "dry-validation"

data/test/gemfiles/Gemfile.ruby-2.3

@@ -0,0 +1,12 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in trailblazer.gemspec
+gemspec
+
+gem "multi_json"
+
+gem "dry-auto_inject"
+gem "dry-matcher"
+
+gem "minitest-line"
+gem "benchmark-ips"

data/test/module_test.rb

@@ -1,13 +1,15 @@
 require 'test_helper'
 require "trailblazer/operation/module"
-require "trailblazer/operation/dispatch"
+require "trailblazer/operation/callback"
+require "trailblazer/operation/contract"
 
 class OperationModuleTest < MiniTest::Spec
   Song = Struct.new(:name, :artist)
   Artist = Struct.new(:id, :full_name)
 
   class Create < Trailblazer::Operation
-    include Trailblazer::Operation::Dispatch
+    include Trailblazer::Operation::Callback
+    include Contract::Explicit
 
     contract do
       property :name
@@ -20,18 +22,21 @@ class OperationModuleTest < MiniTest::Spec
       on_change :notify_me!
     end
 
-    def process(params)
-      @model = Song.new
+    attr_reader :model
+    def call(params)
+      self["model"] = Song.new
 
-      validate(params, @model) do
+      validate(params, model: self["model"]) do
         contract.sync
 
         dispatch!
       end
+
+      self
     end
 
     def dispatched
-      @dispatched ||= []
+      self["dispatched"] ||= []
     end
 
   private
@@ -47,6 +52,8 @@ class OperationModuleTest < MiniTest::Spec
     contract do
       property :artist, inherit: true do
         property :full_name
+
+        puts definitions.inspect
       end
     end
 
@@ -76,18 +83,18 @@ class OperationModuleTest < MiniTest::Spec
   it do
     op = Create.({name: "Feelings", artist: {id: 1, full_name: "The Offspring"}})
 
-    op.dispatched.must_equal [:notify_me!]
-    op.model.name.must_equal "Feelings"
-    op.model.artist.id.must_equal 1
-    op.model.artist.full_name.must_equal nil # property not declared.
+    op["dispatched"].must_equal [:notify_me!]
+    op["model"].name.must_equal "Feelings"
+    op["model"].artist.id.must_equal 1
+    op["model"].artist.full_name.must_equal nil # property not declared.
   end
 
   it do
     op = Update.({name: "Feelings", artist: {id: 1, full_name: "The Offspring"}})
 
-    op.dispatched.must_equal [:notify_me!, :notify_them!, :notify_you!]
-    op.model.name.must_equal "Feelings"
-    op.model.artist.id.must_equal 1
-    op.model.artist.full_name.must_equal "The Offspring" # property declared via Module.
+    op["dispatched"].must_equal [:notify_me!, :notify_them!, :notify_you!]
+    op["model"].name.must_equal "Feelings"
+    op["model"].artist.id.must_equal 1
+    op["model"].artist.full_name.must_equal "The Offspring" # property declared via Module.
   end
-end
+end

data/test/operation/builder_test.rb

@@ -1,41 +1,89 @@
 require "test_helper"
+require "trailblazer/operation/builder"
 
-class OperationBuilderTest < MiniTest::Spec
-  class ParentOperation < Trailblazer::Operation
-    def process(params)
+class BuilderTest < MiniTest::Spec
+  #---
+  # pass proc to Builder[]
+  # this is the puristic way.
+  class A < Trailblazer::Operation
+    builds = ->(klass, options) do
+      return B if options["params"][:sub]
+      klass
+    end
+
+    self.| Builder( builds )
+    self.| :process
+
+    class B < A
     end
 
+    def process(*); self["x"] = self.class end
+  end
+
+  it { A.()["x"].must_equal A }
+  it { A.({ sub: true })["x"].must_equal A::B }
+  it { A::B["builder"].must_equal nil }
+
+  #---
+  # use manual Builders object
+  MyBuilders = Uber::Builder::Builders.new
+  MyBuilders << ->(options) { return self::B if options["params"][:sub] }
+
+  class Create < Trailblazer::Operation
+    self.| Builder( MyBuilders )
+    self["pipetree"].> ->(input, options) { options["x"] = input.class }
+  end
+
+  it { Create.()["x"].must_equal Create }
+
+  #---
+  #- Builder inheritance
+  class B < A
+  end
+
+  it { B["pipetree"].inspect.must_equal %{[>>operation.new,>process]} }
+
+  #---
+  # use Builder DSL
+  # you don't need to include Builder in the pipetree
+  class ParentOperation < Trailblazer::Operation
     class Sub < self
     end
 
-    builds do |params|
-      Sub if params[:sub]
+    include Builder
+    builds -> (options) do
+      return Sub if options["params"][:sub]
     end
+
+    def process(*); self["x"] = self.class end
+    self.| :process
   end
 
-  it { ParentOperation.run({}).last.class.must_equal ParentOperation }
-  it { ParentOperation.run({sub: true}).last.class.must_equal ParentOperation::Sub }
-  it { ParentOperation.({}).class.must_equal ParentOperation }
-  it { ParentOperation.({sub: true}).class.must_equal ParentOperation::Sub }
+  it { ParentOperation.({})["x"].must_equal ParentOperation }
+  it { ParentOperation.({ sub: true })["x"].must_equal ParentOperation::Sub }
 end
 
+#---
+# copying via Operation.builders
 class OperationBuilderClassTest < MiniTest::Spec
   class SuperOperation < Trailblazer::Operation
-    builds do |params|
-      self::Sub if params[:sub] # Sub is defined in ParentOperation.
+    include Builder
+
+    builds do |options|
+      self::Sub if options["params"][:sub] # Sub is defined in ParentOperation.
     end
   end
 
   class ParentOperation < Trailblazer::Operation
-    def process(params)
-    end
-
     class Sub < self
     end
 
-    self.builder_class = SuperOperation.builder_class
+    self.| Builder( SuperOperation.builders )
+
+    def process(*); self["x"] = self.class end
+    self.| :process
   end
 
-  it { ParentOperation.({}).class.must_equal ParentOperation }
-  it { ParentOperation.({sub: true}).class.must_equal ParentOperation::Sub }
-end
+  it { ParentOperation.({})["x"].must_equal ParentOperation }
+  it { ParentOperation.({ sub: true })["x"].must_equal ParentOperation::Sub }
+end