trailblazer 2.0.0 → 2.0.1

data/test/docs/pundit_test.rb

@@ -1,20 +1,20 @@
 require "test_helper"
 
-#:policy
-class MyPolicy
-  def initialize(user, model)
-    @user, @model = user, model
-  end
+  #:policy
+  class MyPolicy
+    def initialize(user, model)
+      @user, @model = user, model
+    end
 
-  def create?
-    @user == Module && @model.id.nil?
-  end
+    def create?
+      @user == Module && @model.id.nil?
+    end
 
-  def new?
-    @user == Class
+    def new?
+      @user == Class
+    end
   end
-end
-#:policy end
+  #:policy end
 
 #--
 # with policy
@@ -29,6 +29,7 @@ class DocsPunditProcTest < Minitest::Spec
   end
   #:pundit end
 
+  it { Create["pipetree"].inspect.must_equal %{[>operation.new,>model.build,>policy.default.eval]} }
   it { Create.({}, "current_user" => Module).inspect("model").must_equal %{<Result:true [#<struct DocsPunditProcTest::Song id=nil>] >} }
   it { Create.({}                          ).inspect("model").must_equal %{<Result:false [#<struct DocsPunditProcTest::Song id=nil>] >} }
 
@@ -45,10 +46,10 @@ class DocsPunditProcTest < Minitest::Spec
   #---
   #- override
   class New < Create
-    override Policy::Pundit( MyPolicy, :new? )
+    step Policy::Pundit( MyPolicy, :new? ), override: true
   end
 
-  it { New["pipetree"].inspect.must_equal %{[>>operation.new,&model.build,&policy.default.eval]} }
+  it { New["pipetree"].inspect.must_equal %{[>operation.new,>model.build,>policy.default.eval]} }
   it { New.({}, "current_user" => Class ).inspect("model").must_equal %{<Result:true [#<struct DocsPunditProcTest::Song id=nil>] >} }
   it { New.({}, "current_user" => nil ).inspect("model").must_equal %{<Result:false [#<struct DocsPunditProcTest::Song id=nil>] >} }
 
@@ -60,12 +61,12 @@ class DocsPunditProcTest < Minitest::Spec
   end
 
   class Update < Edit
-    override Policy::Pundit( MyPolicy, :new?, name: "first" )
+    step Policy::Pundit( MyPolicy, :new?, name: "first" ), override: true
   end
 
-  it { Edit["pipetree"].inspect.must_equal %{[>>operation.new,&policy.first.eval,&policy.second.eval]} }
+  it { Edit["pipetree"].inspect.must_equal %{[>operation.new,>policy.first.eval,>policy.second.eval]} }
   it { Edit.({}, "current_user" => Class).inspect("model").must_equal %{<Result:false [nil] >} }
-  it { Update["pipetree"].inspect.must_equal %{[>>operation.new,&policy.first.eval,&policy.second.eval]} }
+  it { Update["pipetree"].inspect.must_equal %{[>operation.new,>policy.first.eval,>policy.second.eval]} }
   it { Update.({}, "current_user" => Class).inspect("model").must_equal %{<Result:true [nil] >} }
 
   #---

data/test/docs/rescue_test.rb

@@ -17,13 +17,13 @@ class NestedRescueTest < Minitest::Spec
       step ->(options) { options["b"] = true }
       success ->(options) { raise A if options["raise-a"] }
       step ->(options) { options["c"] = true }
-      self.< ->(options) { options["inner-err"] = true }
+      failure ->(options) { options["inner-err"] = true }
     }
     step ->(options) { options["e"] = true }
     failure ->(options) { options["outer-err"] = true }
   end
 
-  it { NestedInsanity["pipetree"].inspect.must_equal %{[>>operation.new,&Rescue:10,&:22,<NestedRescueTest::NestedInsanity:23]} }
+  it { NestedInsanity["pipetree"].inspect.must_equal %{[>operation.new,>Rescue:10,>rescue_test.rb:22,<rescue_test.rb: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] >} }
@@ -148,7 +148,7 @@ class RescueTest < Minitest::Spec
     it { assert_raises(RuntimeError) { Create.( id: "RuntimeError!" ) } }
     it do
       Create.( id: 1, title: "Pie" )
-      Sequel.result.first.must_equal Pipetree::Flow::Right
+      Sequel.result.first.must_equal Pipetree::Railway::Right
     end
   end
 end

data/test/docs/wrap_test.rb

@@ -142,6 +142,7 @@ class WrapTest < Minitest::Spec
 
     def self.call(options, *)
       Sequel.transaction { yield } # yield runs the nested pipe.
+      # return value decides about left or right track!
     end
   end
   #:callable-t end

data/test/operation/callback_test.rb

@@ -13,10 +13,10 @@ class OperationCallbackTest < MiniTest::Spec
       property :name
     end
 
-    self.| Model( Song, :new )
-    self.| Contract::Build()
-    self.| Contract::Validate()
-    self.| Callback( :default )
+    step Model( Song, :new )
+    step Contract::Build()
+    step Contract::Validate()
+    step Callback( :default )
 
 
     extend Callback::DSL
@@ -55,7 +55,7 @@ class OperationCallbackTest < MiniTest::Spec
 
   #---
   #- inheritance
-  it { Update["pipetree"].inspect.must_equal %{[>>operation.new,&model.build,>contract.build,&contract.default.params,&contract.default.validate,&callback.default]} }
+  it { Update["pipetree"].inspect.must_equal %{[>operation.new,>model.build,>contract.build,>contract.default.validate,>callback.default]} }
 
 
   it "invokes all callbacks" do

data/test/operation/contract_test.rb

@@ -1,5 +1,16 @@
 require "test_helper"
-require "trailblazer/operation/contract"
+
+class ContractExtractMacroTest < Minitest::Spec
+  class Create < Trailblazer::Operation
+    step Contract::Validate::Extract( key: "song", params_path: "x" )
+  end
+
+  it { Create["pipetree"].inspect.must_equal %{[>operation.new,>x]} }
+  it { Create.({}).inspect("x").must_equal %{<Result:false [nil] >} }
+  it { Create.({ "song" => Object }).inspect("x").must_equal %{<Result:true [Object] >} }
+end
+
+
 
       require "dry/validation"
 
@@ -14,7 +25,7 @@ class DryValidationTest < Minitest::Spec
     #   required(:id).filled
     # end
 
-    self.| :process
+    step :process
 
     include Procedural::Validate
 
@@ -40,7 +51,7 @@ class DryValidationTest < Minitest::Spec
       required(:id).filled
     end)
 
-    self.& ->(options) { options["contract.params"].(options["params"]).success? }, before: "operation.new"
+    step ->(options) { options["contract.params"].(options["params"]).success? }, before: "operation.new"
   end
 
   it { Update.( id: 1 ).success?.must_equal true }
@@ -71,10 +82,10 @@ class ContractTest < Minitest::Spec
         property :title
       end
 
-      self.> ->(options) { options["model"] = Song.new }
-      # self.| Model( Song, :new )
-      self.| Contract::Build()
-      self.| :process
+      success ->(options) { options["model"] = Song.new }
+      # step Model( Song, :new )
+      step Contract::Build()
+      step :process
 
       include Procedural::Validate
       # TODO: get model automatically in validate!
@@ -216,9 +227,9 @@ class ValidateTest < Minitest::Spec
       end
     end
 
-    self.| Model( Song, :new ) # FIXME.
-    self.| Contract::Build()
-    self.& :process
+    step Model( Song, :new ) # FIXME.
+    step Contract::Build()
+    step :process
   end
 
   # validate returns the #validate result
@@ -258,9 +269,9 @@ class ValidateTest < Minitest::Spec
       validates :title, presence: true
     end
 
-    self.| Model( Song, :new ) # FIXME.
-    self.| Contract::Build()
-    self.| Contract::Validate() # generic validate call for you.
+    step Model( Song, :new ) # FIXME.
+    step Contract::Build()
+    step Contract::Validate() # generic validate call for you.
 
     # include Procedural::Validate
     ->(*) { validate(options["params"][:song]) } # <-- TODO
@@ -291,9 +302,9 @@ class ValidateTest < Minitest::Spec
       validates :title, presence: true
     end
 
-    self.| Model( Song, :new ) # FIXME.
-    self.| Contract::Build()
-    self.| Contract::Validate( key: :song) # generic validate call for you.
+    step Model( Song, :new ) # FIXME.
+    step Contract::Build()
+    step Contract::Validate( key: :song) # generic validate call for you.
     # ->(*) { validate(options["params"][:song]) } # <-- TODO
     step Contract::Persist( method: :sync )
   end
@@ -315,14 +326,14 @@ class ValidateTest < Minitest::Spec
   class New < Upsert
   end
 
-  it { New["pipetree"].inspect.must_equal %{[>>operation.new,&model.build,>contract.build,&contract.default.params,&contract.default.validate,&persist.save]} }
+  it { New["pipetree"].inspect.must_equal %{[>operation.new,>model.build,>contract.build,>contract.default.validate,>persist.save]} }
 
   #- overwriting Validate
   class NewHit < Upsert
-    override Contract::Validate( key: :hit )
+    step Contract::Validate( key: :hit ), override: true
   end
 
-  it { NewHit["pipetree"].inspect.must_equal %{[>>operation.new,&model.build,>contract.build,&contract.default.params,&contract.default.validate,&persist.save]} }
+  it { NewHit["pipetree"].inspect.must_equal %{[>operation.new,>model.build,>contract.build,>contract.default.validate,>persist.save]} }
   it { NewHit.(:hit => { title: "Hooray For Me" }).inspect("model").must_equal %{<Result:true [#<struct ContractTest::Song title=\"Hooray For Me\">] >} }
 end
 

data/test/operation/dsl/callback_test.rb

@@ -37,7 +37,7 @@ class DslCallbackTest < MiniTest::Spec
         def admin_default!(*); _invocations << :admin_default!; end
         def after_save!(*);    _invocations << :after_save!; end
 
-        self.| Trailblazer::Operation::Callback[:after_save]
+        step Trailblazer::Operation::Callback[:after_save]
       end
 
       def default!(*); _invocations << :default!; end
@@ -61,7 +61,7 @@ class DslCallbackTest < MiniTest::Spec
       extend Callback::DSL
       callback :after_save, AfterSaveCallback
 
-      self.| Callback[:after_save]
+      step Callback[:after_save]
     end
 
     it { OpWithExternalCallback.("title"=>"Thunder Rising").must_equal([:after_save!]) }

data/test/operation/dsl/contract_test.rb

@@ -14,10 +14,10 @@ class DslContractTest < MiniTest::Spec
     end
 
     def self.included(includer)
-      includer.| Trailblazer::Operation::Model( OpenStruct, :new )
-      includer.| Trailblazer::Operation::Contract::Build()
-      includer.| Trailblazer::Operation::Contract::Validate()
-      includer.| Trailblazer::Operation::Contract::Persist( method: :sync )
+      includer.step Trailblazer::Operation::Model( OpenStruct, :new )
+      includer.step Trailblazer::Operation::Contract::Build()
+      includer.step Trailblazer::Operation::Contract::Validate()
+      includer.step Trailblazer::Operation::Contract::Persist( method: :sync )
       # includer.> ->(op, *) { op["x"] = [] }
     end
   end

data/test/operation/model_test.rb

@@ -9,34 +9,27 @@ class ModelTest < Minitest::Spec
   #---
   # use Model semantics, no customizations.
   class Create < Trailblazer::Operation
-    self.| Model Song, :new
+    step Model Song, :new
   end
 
   # :new new.
   it { Create.({})["model"].inspect.must_equal %{#<struct ModelTest::Song id=nil>} }
 
   class Update < Create
-    override Model(Song, :update)
+    step Model( Song, :find ), override: true
   end
 
   # :find it
   it { Update.({ id: 1 })["model"].inspect.must_equal %{#<struct ModelTest::Song id=1>} }
 
   #- inheritance
-  it { Update["pipetree"].inspect.must_equal %{[>>operation.new,&model.build]} }
-
-  # override #model with Model included.
-  class Upsert < Create
-    def model!(params); params.to_s end
-  end
-
-  it { Upsert.(id: 9)["model"].must_equal %{{:id=>9}} }
+  it { Update["pipetree"].inspect.must_equal %{[>operation.new,>model.build]} }
 
   #---
   # :find_by, exceptionless.
   class Find < Trailblazer::Operation
-    self.| Model Song, :find_by
-    self.| :process
+    step Model Song, :find_by
+    step :process
 
     def process(*); self["x"] = true end
   end
@@ -56,50 +49,12 @@ class ModelTest < Minitest::Spec
     Find.(id: 9)["model"].inspect.must_equal %{#<struct ModelTest::Song id=9>}
   end
 
-  #---
-  # override #model!, without any Model inclusions.
-  class Delete < Trailblazer::Operation
-    self.| Model :model!
-    def model!(params); params.to_s end
-  end
-
-  it { Delete.(id: 1)["model"].must_equal %{{:id=>1}} }
-
-  #---
-  # creating the model before operation instantiation (ex Model::External)
-  class Show < Create
-    extend Model::BuildMethods # FIXME: how do we communicate that and prevent the include from Model[] ?
-    self.| Model( Song, :update ), before: "operation.new"
-  end
-
-  it { Show.({id: 1})["model"].inspect.must_equal %{#<struct ModelTest::Song id=1>} }
-
-
-  # TODO: with builder!
-
-  #---
-  # provide your own object ModelBuilder that includes BuilderMethods.
-  # this tests that BuildMethods is interchangable and acts as an example how to  decouple
-  # the model building from the operation.
-  class Index < Trailblazer::Operation
-    # DISCUSS: help user to do this kind of behavior?
-    # model Song, :find # ModelBuilder can read this via skills that we pass to it.
-    self["model.class"] = Song
-    self["model.action"] = :find
-
-    # this is to be able to use BuildModel.
-    class ModelBuilder
-      include Trailblazer::Operation::Model::BuildMethods # #instantiate_model and so on.
-      alias_method :call, :model!
-
-      def initialize(skills); @delegator = skills  end
-
-      extend Uber::Delegates
-      delegates :@delegator, :[]
-    end
-
-    self.> ->(options) { options["model"] = ModelBuilder.new(options).(options["params"]) }, after: "operation.new"
-  end
+  # #---
+  # # creating the model before operation instantiation (ex Model::External)
+  # class Show < Create
+  #   extend Model::BuildMethods # FIXME: how do we communicate that and prevent the include from Model[] ?
+  #   step Model( Song, :update ), before: "operation.new"
+  # end
 
-  it { Index.(id: 1)["model"].inspect.must_equal %{#<struct ModelTest::Song id=1>} }
+  # it { Show.({id: 1})["model"].inspect.must_equal %{#<struct ModelTest::Song id=1>} }
 end

data/test/operation/persist_test.rb

@@ -11,12 +11,12 @@ class PersistTest < Minitest::Spec
       property :title
     end
 
-    self.| Model( Song, :new )
-    self.| Contract::Build()
-    self.| Contract::Validate()
-    self.< ->(options) { options["1. fail"] = "Validate" }
-    self.| Contract::Persist()
-    self.< ->(options) { options["2. fail"] = "Persist" }
+    step Model( Song, :new )
+    step Contract::Build()
+    step Contract::Validate()
+    failure ->(options) { options["1. fail"] = "Validate" }
+    step Contract::Persist()
+    failure ->(options) { options["2. fail"] = "Persist" }
   end
 
   it { Create.(title: "In Recital")["model"].title.must_equal "In Recital" }
@@ -35,7 +35,7 @@ class PersistTest < Minitest::Spec
   class Update < Create
   end
 
-  it { Update["pipetree"].inspect.must_equal %{[>>operation.new,&model.build,>contract.build,&contract.default.params,&contract.default.validate,<PersistTest::Update:17,&persist.save,<PersistTest::Update:19]} }
+  it { Update["pipetree"].inspect.must_equal %{[>operation.new,>model.build,>contract.build,>contract.default.validate,<persist_test.rb:17,>persist.save,<persist_test.rb:19]} }
 
   #---
   it do

data/test/operation/pipedream_test.rb

@@ -20,22 +20,22 @@ class PipedreamTest < Minitest::Spec
 
 
 
-    self.|         Model[ Song, :new ]      # model!)
-    self.| Policy::Guard[ ->(options){ options["current_user"] == ::Module } ]
-    self.|      Contract[ MyContract]
-    self.|        Policy[ Auth, :user_and_model?]
-    self.<      Contract[ MyContract]
+    step         Model[ Song, :new ]      # model!)
+    step Policy::Guard[ ->(options){ options["current_user"] == ::Module } ]
+    step      Contract[ MyContract]
+    step        Policy[ Auth, :user_and_model?]
+    failure      Contract[ MyContract]
 
-    # self.| :model
-    # self.| :guard
-    # self.| :contract
+    # step :model
+    # step :guard
+    # step :contract
 
 
     # ok Model[Song, :new]      # model!)
     # ok Policy::Guard[ ->(options){ options["current_user"] == ::Module } ]
     # ok Contract[MyContract]
     # fail Contract[MyContract]
-    # self.|> "contract"
+    # step> "contract"
 
     # | :bla
     # | ->

data/test/operation/pipetree_test.rb

@@ -42,21 +42,21 @@ class PipetreeTest < Minitest::Spec
 
     MyValidate = ->(input, options) { res= input.validate(options["params"]) { |f| f.sync } }
     # we can have a separate persist step and wrap in transaction. where do we pass contract, though?
-    self.& MyValidate, before: Call #replace: Contract::ValidLegacySwitch
+    step MyValidate, before: Call #replace: Contract::ValidLegacySwitch
     #
     MyAfterSave = ->(input, options) { input["after_save"] = true }
-    self.> MyAfterSave, after: MyValidate
+    success MyAfterSave, after: MyValidate
 
     ValidateFailureLogger = ->(input, options) { input["validate fail"] = true }
-    self.< ValidateFailureLogger, after: MyValidate
+    failure ValidateFailureLogger, after: MyValidate
 
-    self.> ->(input, options) { input.process(options["params"]) }, replace: Call, name: "my.params"
+    success ->(input, options) { input.process(options["params"]) }, replace: Call, name: "my.params"
 
     include Model
 
     LogBreach = ->(input, options) { input.log_breach! }
 
-    self.< LogBreach, after: Policy::Evaluate
+    failure LogBreach, after: Policy::Evaluate
 
     model Song
     policy ->(*) { self["current_user"] }