trailblazer 2.0.7 → 2.1.0.beta1

data/test/docs/guard_test.rb

@@ -3,46 +3,33 @@ require "test_helper"
 #--
 # with proc
 class DocsGuardProcTest < Minitest::Spec
-  # test without KWs, only options.
-  class Update < Trailblazer::Operation
-    step Policy::Guard( ->(options) { options["params"][:pass] } )
-    step ->(options, *) { options["x"] = true }
-  end
-
-  it { Update.(pass: false)["x"].must_equal nil }
-  it { Update.(pass: true)["x"].must_equal true }
-  # TODO: test excp when current_user not available
-
   #:proc
   class Create < Trailblazer::Operation
-    step Policy::Guard( ->(options, params:, **) { params[:pass] } )
+    step Policy::Guard( ->(options, pass:, **) { pass } )
     #~pipeonly
     step :process
 
-    def process(*)
-      self["x"] = true
+    def process(options, **)
+      options["x"] = true
     end
     #~pipeonly end
   end
   #:proc end
 
-  it { Create.(pass: false)["x"].must_equal nil }
+  it { Create.(pass: false)["x"].must_be_nil }
   it { Create.(pass: true)["x"].must_equal true }
 
   #- result object, guard
   it { Create.(pass: true)["result.policy.default"].success?.must_equal true }
   it { Create.(pass: false)["result.policy.default"].success?.must_equal false }
 
-
-
-
-   #---
+  #---
   #- Guard inheritance
   class New < Create
     step Policy::Guard( ->(options, current_user:, **) { current_user } ), override: true
   end
 
-  it { New["pipetree"].inspect.must_equal %{[>operation.new,>policy.default.eval,>process]} }
+  it { Trailblazer::Operation::Inspect.(New).must_equal %{[>policy.default.eval,>process]} }
 end
 
 #---
@@ -52,8 +39,8 @@ class DocsGuardTest < Minitest::Spec
   class MyGuard
     include Uber::Callable
 
-    def call(options, params:, **)
-      params[:pass]
+    def call(options, pass:, **)
+      pass
     end
   end
   #:callable end
@@ -63,12 +50,15 @@ class DocsGuardTest < Minitest::Spec
     step Policy::Guard( MyGuard.new )
     #~pipe-only
     step :process
-    def process(*); self[:x] = true; end
+
+    def process(options, **)
+      options[:x] = true
+    end
     #~pipe-only end
   end
   #:callable-op end
 
-  it { Create.(pass: false)[:x].must_equal nil }
+  it { Create.(pass: false)[:x].must_be_nil }
   it { Create.(pass: true)[:x].must_equal true }
 end
 
@@ -79,12 +69,15 @@ class DocsGuardMethodTest < Minitest::Spec
   class Create < Trailblazer::Operation
     step Policy::Guard( :pass? )
 
-    def pass?(options, params:, **)
-      params[:pass]
+    def pass?(options, pass:, **)
+      pass
     end
     #~pipe-onlyy
     step :process
-    def process(*); self["x"] = true; end
+
+    def process(options, **)
+      options["x"] = true
+    end
     #~pipe-onlyy end
   end
   #:method end
@@ -103,12 +96,12 @@ class DocsGuardNamedTest < Minitest::Spec
   end
   #:name end
 
-  it { Create.({}, "current_user" => nil   )["result.policy.user"].success?.must_equal false }
-  it { Create.({}, "current_user" => Module)["result.policy.user"].success?.must_equal true }
+  it { Create.(:current_user => nil   )["result.policy.user"].success?.must_equal false }
+  it { Create.(:current_user => Module)["result.policy.user"].success?.must_equal true }
 
   it {
   #:name-result
-  result = Create.({}, "current_user" => true)
+  result = Create.(:current_user => true)
   result["result.policy.user"].success? #=> true
   #:name-result end
   }
@@ -123,13 +116,13 @@ class DocsGuardInjectionTest < Minitest::Spec
   end
   #:di-op end
 
-  it { Create.({}, "current_user" => Module).inspect("").must_equal %{<Result:true [nil] >} }
+  it { Create.(:current_user => Module).inspect("").must_equal %{<Result:true [nil] >} }
   it {
     result =
   #:di-call
   Create.({},
-    "current_user"        => Module,
-    "policy.default.eval" => Trailblazer::Operation::Policy::Guard.build(->(options) { false })
+    :current_user        => Module,
+    "policy.default.eval" => Trailblazer::Operation::Policy::Guard.build(->(options, **) { false })
   )
   #:di-call end
     result.inspect("").must_equal %{<Result:false [nil] >} }
@@ -143,7 +136,7 @@ class DocsGuardMissingKeywordTest < Minitest::Spec
   end
 
   it { assert_raises(ArgumentError) { Create.() } }
-  it { Create.({}, "current_user" => Module).success?.must_equal true }
+  it { Create.(:current_user => Module).success?.must_equal true }
 end
 
 #---
@@ -157,10 +150,10 @@ class DocsGuardPositionTest < Minitest::Spec
   end
   #:before end
 
-  it { Create["pipetree"].inspect.must_equal %{[>operation.new,>policy.default.eval,>model!]} }
+  it { Trailblazer::Operation::Inspect.(Create).must_equal %{[>policy.default.eval,>model!]} }
   it do
     #:before-pipe
-      puts Create["pipetree"].inspect(style: :rows) #=>
+      Trailblazer::Operation::Inspect.(Create, style: :rows) #=>
        # 0 ========================>operation.new
        # 1 ==================>policy.default.eval
        # 2 ===============================>model!

data/test/docs/macro_test.rb

@@ -28,7 +28,7 @@ class DocsMacroTest < Minitest::Spec
   end
 =end
 
-  it { Create["pipetree"].inspect.must_equal %{[>operation.new,>my_policy.manager]} }
+  it { Operation::Inspect.(Create).must_equal %{[>my_policy.manager]} }
 end
 
 # injectable option

data/test/docs/model_test.rb

@@ -20,11 +20,11 @@ class DocsModelTest < Minitest::Spec
 
   it do
     #:create
-    result = Create.({})
-    result["model"] #=> #<struct Song id=nil, title=nil>
+    result = Create.(params: {})
+    result[:model] #=> #<struct Song id=nil, title=nil>
     #:create end
 
-    result["model"].inspect.must_equal %{#<struct DocsModelTest::Song id=nil, title=nil>}
+    result[:model].inspect.must_equal %{#<struct DocsModelTest::Song id=nil, title=nil>}
   end
 
   #:update
@@ -36,21 +36,21 @@ class DocsModelTest < Minitest::Spec
 
   it do
     #:update-ok
-    result = Update.({ id: 1 })
-    result["model"] #=> #<struct Song id=1, title="Roxanne">
+    result = Update.(params: { id: 1 })
+    result[:model] #=> #<struct Song id=1, title="Roxanne">
     #:update-ok end
 
-    result["model"].inspect.must_equal %{#<struct DocsModelTest::Song id=1, title=nil>}
+    result[:model].inspect.must_equal %{#<struct DocsModelTest::Song id=1, title=nil>}
   end
 
   it do
     #:update-fail
-    result = Update.({})
-    result["model"] #=> nil
+    result = Update.(params: {})
+    result[:model] #=> nil
     result.success? #=> false
     #:update-fail end
 
-    result["model"].must_be_nil
+    result[:model].must_be_nil
     result.success?.must_equal false
   end
 
@@ -62,14 +62,14 @@ class DocsModelTest < Minitest::Spec
   #:show end
 
   it do
-    result = Show.({ id: 1 })
+    result = Show.(params: { id: 1 })
 
     #:show-ok
-    result = Show.({ id: 1 })
-    result["model"] #=> #<struct Song id=1, title="Roxanne">
+    result = Show.(params: { id: 1 })
+    result[:model] #=> #<struct Song id=1, title="Roxanne">
     #:show-ok end
 
     result.success?.must_equal true
-    result["model"].inspect.must_equal %{#<struct DocsModelTest::Song id=100, title=nil>}
+    result[:model].inspect.must_equal %{#<struct DocsModelTest::Song id=100, title=nil>}
   end
 end

data/test/docs/nested_test.rb

@@ -11,6 +11,7 @@ class DocsNestedOperationTest < Minitest::Spec
   #- nested operations
   #:edit
   class Edit < Trailblazer::Operation
+    extend ClassDependencies
     extend Contract::DSL
 
     contract do
@@ -26,97 +27,63 @@ class DocsNestedOperationTest < Minitest::Spec
   #:update
   class Update < Trailblazer::Operation
     step Nested( Edit )
+    # step ->(options, **) { puts options.keys.inspect }
     step Contract::Validate()
+
     step Contract::Persist( method: :sync )
   end
   #:update end
 
-  puts Update["pipetree"].inspect(style: :rows)
+  # puts Update["pipetree"].inspect(style: :rows)
 
   #-
   # Edit allows grabbing model and contract
   it do
   #:edit-call
-  result = Edit.(id: 1)
+  result = Edit.(params: {id: 1})
 
-  result["model"]            #=> #<Song id=1, title=\"Bristol\">
+  result[:model]            #=> #<Song id=1, title=\"Bristol\">
   result["contract.default"] #=> #<Reform::Form ..>
   #:edit-call end
-    result.inspect("model").must_equal %{<Result:true [#<struct DocsNestedOperationTest::Song id=1, title=\"Bristol\">] >}
-    result["contract.default"].model.must_equal result["model"]
+    result.inspect(:model).must_equal %{<Result:true [#<struct DocsNestedOperationTest::Song id=1, title=\"Bristol\">] >}
+    result["contract.default"].model.must_equal result[:model]
+  end
+
+  it "provides all steps for Introspect" do
+     Trailblazer::Activity::Trace.compute_debug( Edit ).values.must_equal [{:id=>"model.build"}, {:id=>"contract.build"}]
+    Trailblazer::Activity::Trace.compute_debug( Update ).values.must_equal [{:id=>"Nested(DocsNestedOperationTest::Edit)"}, {:id=>"contract.default.validate"}, {:id=>"persist.save"}, {:id=>"model.build"}, {:id=>"contract.build"}, {:id=>"contract.default.params_extract"}, {:id=>"contract.default.call"}]
   end
 
+#- test Edit circuit-level.
+it do
+  signal, (result, _) = Edit.__call__( [Trailblazer::Context( params: {id: 1} ), {}] )
+  result[:model].inspect.must_equal %{#<struct DocsNestedOperationTest::Song id=1, title=\"Bristol\">}
+end
+
   #-
-  # Update also allows grabbing model and contract
+  # Update also allows grabbing Edit/model and Edit/contract
   it do
   #:update-call
-  result = Update.(id: 1, title: "Call It A Night")
+  result = Update.(params: {id: 1, title: "Call It A Night"})
 
-  result["model"]            #=> #<Song id=1 , title=\"Call It A Night\">
+  result[:model]            #=> #<Song id=1 , title=\"Call It A Night\">
   result["contract.default"] #=> #<Reform::Form ..>
   #:update-call end
-    result.inspect("model").must_equal %{<Result:true [#<struct DocsNestedOperationTest::Song id=1, title=\"Call It A Night\">] >}
-    result["contract.default"].model.must_equal result["model"]
+    result.inspect(:model).must_equal %{<Result:true [#<struct DocsNestedOperationTest::Song id=1, title=\"Call It A Night\">] >}
+    result["contract.default"].model.must_equal result[:model]
   end
 
   #-
   # Edit is successful.
   it do
-    result = Update.({ id: 1, title: "Miami" }, "current_user" => Module)
-    result.inspect("model").must_equal %{<Result:true [#<struct DocsNestedOperationTest::Song id=1, title="Miami">] >}
+    result = Update.(params: { id: 1, title: "Miami" }, current_user: Module)
+    result.inspect(:model).must_equal %{<Result:true [#<struct DocsNestedOperationTest::Song id=1, title="Miami">] >}
   end
 
   # Edit fails
   it do
-    Update.(id: 2).inspect("model").must_equal %{<Result:false [nil] >}
-  end
-
-  #---
-  #- shared data
-  class B < Trailblazer::Operation
-    success ->(options) { options["can.B.see.it?"] = options["this.should.not.be.visible.in.B"] }
-    success ->(options) { options["can.B.see.current_user?"] = options["current_user"] }
-    success ->(options) { options["can.B.see.params?"] = options["params"] }
-    success ->(options) { options["can.B.see.A.class.data?"] = options["A.class.data"] }
-  end
-
-  class A < Trailblazer::Operation
-    self["A.class.data"] = true
-
-    success ->(options) { options["this.should.not.be.visible.in.B"] = true }
-    step Nested( B )
-  end
-
-  # mutual data from A doesn't bleed into B.
-  it { A.()["can.B.see.it?"].must_equal nil }
-  it { A.()["this.should.not.be.visible.in.B"].must_equal true }
-  # runtime dependencies are visible in B.
-  it { A.({}, "current_user" => Module)["can.B.see.current_user?"].must_equal Module }
-  it { A.({ a: 1 })["can.B.see.params?"].must_equal({ a: 1 }) }
-  # class data from A doesn't bleed into B.
-  it { A.()["can.B.see.A.class.data?"].must_equal nil }
-
-
-  # cr_result = Create.({}, "result" => result)
-  # puts cr_result["model"]
-  # puts cr_result["contract.default"]
-
-  #---
-  #- Nested( .., input: )
-  class C < Trailblazer::Operation
-    self["C.class.data"] = true
-
-    success ->(options) { options["this.should.not.be.visible.in.B"] = true }
-
-    step Nested( B, input: ->(options, runtime_data:, mutable_data:, **) {
-      runtime_data.merge( "this.should.not.be.visible.in.B" => mutable_data["this.should.not.be.visible.in.B"] )
-    } )
+    Update.(params: {id: 2}).inspect(:model).must_equal %{<Result:false [nil] >}
   end
-
-  it { C.()["can.B.see.it?"].must_equal true }
-  it { C.()["this.should.not.be.visible.in.B"].must_equal true } # this IS visible since we use :input!
-  it { C.({}, "current_user" => Module)["can.B.see.current_user?"].must_equal Module }
-  it { C.()["can.B.see.A.class.data?"].must_equal nil }
 end
 
 class NestedInput < Minitest::Spec
@@ -128,19 +95,20 @@ class NestedInput < Minitest::Spec
 
   #:input-pi
   class MultiplyByPi < Trailblazer::Operation
-    step ->(options) { options["pi_constant"] = 3.14159 }
-    step Nested( Multiplier, input: ->(options, mutable_data:, runtime_data:, **) do
-      { "y" => mutable_data["pi_constant"],
-        "x" => runtime_data["x"] }
+    step ->(options, **) { options["pi_constant"] = 3.14159 }
+    step Nested( Multiplier, input: ->(options, **) do
+      { "y" => options["pi_constant"],
+        "x" => options["x"]
+      }
     end )
   end
   #:input-pi end
 
-  it { MultiplyByPi.({}, "x" => 9).inspect("product").must_equal %{<Result:true [28.27431] >} }
+  it { MultiplyByPi.("x" => 9).inspect("product").must_equal %{<Result:true [28.27431] >} }
 
   it do
     #:input-result
-    result = MultiplyByPi.({}, "x" => 9)
+    result = MultiplyByPi.("x" => 9)
     result["product"] #=> [28.27431]
     #:input-result end
   end
@@ -151,12 +119,10 @@ class NestedInputCallable < Minitest::Spec
 
   #:input-callable
   class MyInput
-    extend Uber::Callable
-
-    def self.call(options, mutable_data:, runtime_data:, **)
+    def self.call(options, **)
       {
-        "y" => mutable_data["pi_constant"],
-        "x" => runtime_data["x"]
+        "y" => options["pi_constant"],
+        "x" => options["x"]
       }
     end
   end
@@ -164,12 +130,12 @@ class NestedInputCallable < Minitest::Spec
 
   #:input-callable-op
   class MultiplyByPi < Trailblazer::Operation
-    step ->(options) { options["pi_constant"] = 3.14159 }
+    step ->(options, **) { options["pi_constant"] = 3.14159 }
     step Nested( Multiplier, input: MyInput )
   end
   #:input-callable-op end
 
-  it { MultiplyByPi.({}, "x" => 9).inspect("product").must_equal %{<Result:true [28.27431] >} }
+  it { MultiplyByPi.("x" => 9).inspect("product").must_equal %{<Result:true [28.27431] >} }
 end
 
 #---
@@ -179,10 +145,10 @@ class NestedOutput < Minitest::Spec
 
   #:output
   class Update < Trailblazer::Operation
-    step Nested( Edit, output: ->(options, mutable_data:, **) do
+    step Nested( Edit, output: ->(options, **) do
       {
-        "contract.my" => mutable_data["contract.default"],
-        "model"       => mutable_data["model"]
+        "contract.my" => options["contract.default"],
+        model:           options[:model]
       }
     end )
     step Contract::Validate( name: "my" )
@@ -190,55 +156,21 @@ class NestedOutput < Minitest::Spec
   end
   #:output end
 
-  it { Update.( id: 1, title: "Call It A Night" ).inspect("model", "contract.default").must_equal %{<Result:true [#<struct DocsNestedOperationTest::Song id=1, title=\"Call It A Night\">, nil] >} }
+  it { Update.( params: {id: 1, title: "Call It A Night"} ).inspect(:model, "contract.default").
+      must_equal %{<Result:true [#<struct DocsNestedOperationTest::Song id=1, title=\"Call It A Night\">, nil] >} }
 
   it do
-    result = Update.( id: 1, title: "Call It A Night" )
+    result = Update.( params: {id: 1, title: "Call It A Night"} )
 
-    result["model"]            #=> #<Song id=1 , title=\"Call It A Night\">
+    result[:model]            #=> #<Song id=1 , title=\"Call It A Night\">
   end
 end
 
-class NestedClassLevelTest < Minitest::Spec
-  #:class-level
-  class New < Trailblazer::Operation
-    step ->(options) { options["class"] = true }, before: "operation.new"
-    step ->(options) { options["x"] = true }
-  end
-
-  class Create < Trailblazer::Operation
-    step Nested( New )
-    step ->(options) { options["y"] = true }
-  end
-  #:class-level end
-
-  it { Create.().inspect("x", "y").must_equal %{<Result:true [true, true] >} }
-  it { Create.(); Create["class"].must_equal nil }
-end
-
 #---
 # Nested( ->{} )
 class NestedWithCallableTest < Minitest::Spec
   Song = Struct.new(:id, :title)
 
-  class X < Trailblazer::Operation
-    step ->(options, params:, **) { options["params.original"] = params }
-    step ->(options) { options["x"] = true }
-  end
-
-  class Y < Trailblazer::Operation
-    step ->(options) { options["y"] = true }
-  end
-
-  class A < Trailblazer::Operation
-    step ->(options) { options["z"] = true }
-    step Nested( ->(options, *) { options["class"] } )
-  end
-
-  it { A.({ a: 1 }, "class" => X).inspect("x", "y", "z", "params.original").must_equal "<Result:true [true, nil, true, {:a=>1}] >" }
-  it { A.({}, "class" => Y).inspect("x", "y", "z").must_equal "<Result:true [nil, true, true] >" }
-  # it { Create.({}).inspect("x", "y", "z").must_equal "<Result:true [nil, true, true] >" }
-
   class Song
     module Contract
       class Create < Reform::Form
@@ -277,8 +209,8 @@ class NestedWithCallableTest < Minitest::Spec
   let (:admin) { User.new(true) }
   let (:anonymous) { User.new(false) }
 
-  it { Create.({}, "current_user" => anonymous).inspect("x").must_equal %{<Result:true [true] >} }
-  it { Create.({}, "current_user" => admin)    .inspect("x").must_equal %{<Result:true [nil] >} }
+  it { Create.(params: {}, current_user: anonymous).inspect("x").must_equal %{<Result:true [true] >} }
+  it { Create.(params: {}, current_user: admin)    .inspect("x").must_equal %{<Result:true [nil] >} }
 
   #---
   #:method
@@ -286,13 +218,13 @@ class NestedWithCallableTest < Minitest::Spec
     step Nested( :build! )
 
     def build!(options, current_user:nil, **)
-      current_user.admin? ? Create::Admin : Create::NeedsModeration
+        current_user.admin? ? Create::Admin : Create::NeedsModeration
     end
   end
   #:method end
 
-  it { Update.({}, "current_user" => anonymous).inspect("x").must_equal %{<Result:true [true] >} }
-  it { Update.({}, "current_user" => admin)    .inspect("x").must_equal %{<Result:true [nil] >} }
+  it { Update.(params: {}, current_user: anonymous).inspect("x").must_equal %{<Result:true [true] >} }
+  it { Update.(params: {}, current_user: admin)    .inspect("x").must_equal %{<Result:true [nil] >} }
 
   #---
   #:callable-builder
@@ -312,8 +244,8 @@ class NestedWithCallableTest < Minitest::Spec
   end
   #:callable end
 
-  it { Delete.({}, "current_user" => anonymous).inspect("x").must_equal %{<Result:true [true] >} }
-  it { Delete.({}, "current_user" => admin)    .inspect("x").must_equal %{<Result:true [nil] >} }
+  it { Delete.(params: {}, current_user: anonymous).inspect("x").must_equal %{<Result:true [true] >} }
+  it { Delete.(params: {}, current_user: admin)    .inspect("x").must_equal %{<Result:true [nil] >} }
 end
 
 # builder: Nested + deviate to left if nil / skip_track if true
@@ -330,5 +262,5 @@ class NestedNameTest < Minitest::Spec
     # ...
   end
 
-  it { Create["pipetree"].inspect.must_equal %{[>operation.new,>Nested(NestedNameTest::Create::Present)]} }
+  it { Operation::Inspect.(Create).must_equal %{[>>Nested(NestedNameTest::Create::Present)]} }
 end