trailblazer 2.0.7 → 2.1.0.beta1

data/test/docs/trace_test.rb

@@ -0,0 +1,82 @@
+require "test_helper"
+
+class DocsTraceTest < Minitest::Spec
+  Song = Struct.new(:id, :title)
+
+  class MyContract < Reform::Form
+    property :title
+  end
+
+  class Create < Trailblazer::Operation
+    class Present < Trailblazer::Operation
+      step Model( Song, :new )
+      step Contract::Build( constant: MyContract )
+    end
+
+    step Nested( Present )
+    step Contract::Validate( key: :song )
+    step Contract::Persist()
+    step :notify_band
+
+    def notify_band(options, **)
+      true
+    end
+  end
+
+  let(:params)       { {} }
+  let(:current_user) { Module }
+
+  it do
+    #:trace
+    result = Create::Present.trace( params: params, current_user: current_user )
+    puts result.wtf?
+
+    # =>
+    # |-- Start.default
+    # |-- model.build
+    # |-- contract.build
+    # `-- End.success
+    #:trace end
+
+    result.wtf.gsub(/0x\w+/, "").must_equal %{|-- #<Trailblazer::Activity::Start:>
+|-- model.build
+|-- contract.build
+`-- #<Trailblazer::Operation::Railway::End::Success:>}
+  end
+
+  it do
+    #:trace-cpx
+    result = Create.trace( params: params, current_user: current_user )
+    puts result.wtf?
+
+    # =>
+    # |-- #<Trailblazer::Activity::Nested:0x000000031960d8>
+    # |   |-- Start.default
+    # |   |-- model.build
+    # |   |-- contract.build
+    # |   |-- End.success
+    # |   `-- #<Trailblazer::Activity::Nested:0x000000031960d8>
+    # |-- #<Trailblazer::Activity::Nested:0x0000000311f3e8>
+    # |   |-- Start.default
+    # |   |-- contract.default.params
+    # |   |-- End.failure
+    # |   `-- #<Trailblazer::Activity::Nested:0x0000000311f3e8>
+    # `-- #<Trailblazer::Operation::Railway::End::Failure:0x00000003201fb8>
+    #:trace-cpx end
+
+#     result.wtf?.must_equal %{|-- Start.default
+# |-- model.build
+# |-- contract.build
+# `-- End.success}
+  end
+
+    #   operation = ->(*args) { Create.__call__(*args) }
+
+    # stack, _ = Trailblazer::Circuit::Trace.(
+    #   operation,
+    #   nil,
+    #   options={ a_return: true },
+    # )
+
+    # puts output = Circuit::Trace::Present.tree(stack)
+end

data/test/docs/wrap_test.rb

@@ -1,5 +1,7 @@
 require "test_helper"
 
+# TODO: consume End signal from wrapped
+
 class WrapTest < Minitest::Spec
   Song = Struct.new(:id, :title) do
     def self.find(id)
@@ -7,6 +9,34 @@ class WrapTest < Minitest::Spec
     end
   end
 
+  class DirectWiringTest < Minitest::Spec
+    class Create < Trailblazer::Operation
+      class MyContract < Reform::Form
+        property :title
+      end
+
+      step( Wrap( ->(options, *args, &block) {
+        begin
+          block.call
+        rescue => exception
+          options["result.model.find"] = "argh! because #{exception.class}"
+          [ Railway.fail_fast!, options, *args ]
+        end }) {
+        step ->(options, **) { options["x"] = true }
+        step Model( Song, :find )
+        step Contract::Build( constant: MyContract )
+      }.merge(fast_track: true))
+      step Contract::Validate()
+      step Contract::Persist( method: :sync )
+    end
+
+    it { Create.( params: {id: 1, title: "Prodigal Son"} ).inspect("x", :model).must_equal %{<Result:true [true, #<struct WrapTest::Song id=1, title=\"Prodigal Son\">] >} }
+
+    it "goes directly from Wrap to End.fail_fast" do
+      Create.(params: {}).inspect("x", :model, "result.model.find").must_equal %{<Result:false [true, nil, "argh! because RuntimeError"] >}
+    end
+  end
+
   class Create < Trailblazer::Operation
     class MyContract < Reform::Form
       property :title
@@ -26,26 +56,26 @@ class WrapTest < Minitest::Spec
     step Contract::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\"] >} }
+  it { Create.( params: {id: 1, title: "Prodigal Son"} )["contract.default"].model.inspect.must_equal %{#<struct WrapTest::Song id=1, title="Prodigal Son">} }
+  it { Create.( params: {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 ->(options, **) { options["x"] = true }
         success :noop!
         # ...
       }
 
-      def noop!(options)
+      def noop!(options, **)
       end
     end
 
-    it { Create.().inspect("x").must_equal %{<Result:false [nil] >} }
+    it { Create.(params: {}).inspect("x").must_equal %{<Result:false [nil] >} }
     # returns falsey means deviate to left.
-    it { Create.({}, "yield?" => true).inspect("x").must_equal %{<Result:true [true] >} }
+    it { Create.("yield?" => true).inspect("x").must_equal %{<Result:true [true] >} }
   end
 
   class WrapWithCallableTest < Minitest::Spec
@@ -59,27 +89,16 @@ class WrapTest < Minitest::Spec
 
     class Create < Trailblazer::Operation
       step Wrap( MyWrapper ) {
-        step ->(options) { options["x"] = true }
+        step ->(options, **) { options["x"] = true }
         # ...
       }
     end
 
-    it { Create.().inspect("x").must_equal %{<Result:false [nil] >} }
+    it { Create.(params: {}).inspect("x").must_equal %{<Result:false [nil] >} }
     # returns falsey means deviate to left.
-    it { Create.({}, "yield?" => true).inspect("x").must_equal %{<Result:true [true] >} }
+    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
@@ -115,14 +134,14 @@ class WrapTest < Minitest::Spec
       # handle errors after the wrap
     end
 
-    def notify!(options)
+    def notify!(options, **)
       MyNotifier.mail
     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] >} }
+    it { Create.( params: {title: "Pie"} ).inspect(:model, "x", "err").must_equal %{<Result:true [#<struct WrapTest::Song id=nil, title=\"Pie\">, nil, nil] >} }
   end
 
   class WrapExampleCallableTest < Minitest::Spec
@@ -138,8 +157,6 @@ class WrapTest < Minitest::Spec
 
   #:callable-t
   class MyTransaction
-    extend Uber::Callable
-
     def self.call(options, *)
       Sequel.transaction { yield } # yield runs the nested pipe.
       # return value decides about left or right track!
@@ -170,14 +187,30 @@ class WrapTest < Minitest::Spec
       # handle errors after the wrap
     end
 
-    def notify!(options)
+    def notify!(options, **)
       MyNotifier.mail # 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] >} }
+    it { Create.( params: {title: "Pie"} ).inspect(:model, "x", "err").must_equal %{<Result:true [#<struct WrapTest::Song id=nil, title=\"Pie\">, nil, nil] >} }
+  end
+
+  class WrapWithMethodTest < Minitest::Spec
+    class Create < Trailblazer::Operation
+      step Model( Song, :new )
+      step Wrap ->(options, *, &block) { block.call } {
+        step :check_model!
+
+      }
+
+      def check_model!(options, model:, **)
+        options["x"] = model
+      end
+    end
+
+    it { Create.(params: {}) }
   end
 end
 

data/test/module_test.rb

@@ -1,100 +1,100 @@
-require 'test_helper'
-require "trailblazer/operation/module"
-require "trailblazer/operation/callback"
-require "trailblazer/operation/contract"
+# require 'test_helper'
+# require "trailblazer/operation/module"
+# require "trailblazer/operation/callback"
+# require "trailblazer/operation/contract"
 
-class OperationModuleTest < MiniTest::Spec
-  Song = Struct.new(:name, :artist)
-  Artist = Struct.new(:id, :full_name)
+# class OperationModuleTest < MiniTest::Spec
+#   Song = Struct.new(:name, :artist)
+#   Artist = Struct.new(:id, :full_name)
 
-  class Create < Trailblazer::Operation
-    include Trailblazer::Operation::Callback
-    include Contract::Explicit
+#   class Create < Trailblazer::Operation
+#     include Trailblazer::Operation::Callback
+#     include Contract::Explicit
 
-    contract do
-      property :name
-      property :artist, populate_if_empty: Artist do
-        property :id
-      end
-    end
+#     contract do
+#       property :name
+#       property :artist, populate_if_empty: Artist do
+#         property :id
+#       end
+#     end
 
-    callback do
-      on_change :notify_me!
-    end
+#     callback do
+#       on_change :notify_me!
+#     end
 
-    attr_reader :model
-    def call(params)
-      self["model"] = Song.new
+#     attr_reader :model
+#     def call(params)
+#       self["model"] = Song.new
 
-      validate(params, model: self["model"]) do
-        contract.sync
+#       validate(params, model: self["model"]) do
+#         contract.sync
 
-        dispatch!
-      end
+#         dispatch!
+#       end
 
-      self
-    end
+#       self
+#     end
 
-    def dispatched
-      self["dispatched"] ||= []
-    end
+#     def dispatched
+#       self["dispatched"] ||= []
+#     end
 
-  private
-    def notify_me!(*)
-      dispatched << :notify_me!
-    end
-  end
+#   private
+#     def notify_me!(*)
+#       dispatched << :notify_me!
+#     end
+#   end
 
 
-  module SignedIn
-    include Trailblazer::Operation::Module
+#   module SignedIn
+#     include Trailblazer::Operation::Module
 
-    contract do
-      property :artist, inherit: true do
-        property :full_name
+#     contract do
+#       property :artist, inherit: true do
+#         property :full_name
 
-        puts definitions.inspect
-      end
-    end
+#         puts definitions.inspect
+#       end
+#     end
 
-    callback do
-      on_change :notify_you!
-    end
+#     callback do
+#       on_change :notify_you!
+#     end
 
-    def notify_you!(*)
-      dispatched << :notify_you!
-    end
-  end
+#     def notify_you!(*)
+#       dispatched << :notify_you!
+#     end
+#   end
 
 
-  class Update < Create
-    callback do
-      on_change :notify_them!
-    end
+#   class Update < Create
+#     callback do
+#       on_change :notify_them!
+#     end
 
-    include SignedIn
+#     include SignedIn
 
-    def notify_them!(*)
-      dispatched << :notify_them!
-    end
-  end
+#     def notify_them!(*)
+#       dispatched << :notify_them!
+#     end
+#   end
 
 
-  it do
-    op = Create.({name: "Feelings", artist: {id: 1, full_name: "The Offspring"}})
+#   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.
-  end
+#     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"}})
+#   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.
-  end
-end
+#     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

data/test/nested_test.rb

@@ -0,0 +1,293 @@
+require "test_helper"
+
+# exec_context nach Nested
+
+class NestedTest < Minitest::Spec
+  #---
+  #- shared data
+  class B < Trailblazer::Operation
+    pass ->(options, **) { options["can.B.see.A.mutable.data?"] = options["mutable.data.from.A"] }
+    pass ->(options, **) { options["can.B.see.current_user?"]   = options["current_user"] }
+    pass ->(options, **) { options["can.B.see.params?"]         = options["params"] }
+    pass ->(options, **) { options["can.B.see.A.class.data?"]   = options["A.class.data"] }
+    pass ->(options, **) { options["can.B.see.container.data?"] = options["some.container.data"] }
+    pass ->(options, **) { options["mutable.data.from.B"]       = "from B!" }
+  end
+
+  class A < Trailblazer::Operation
+    extend ClassDependencies
+    self["A.class.data"] = "yes"                                   # class data on A
+
+    pass ->(options, **) { options["mutable.data.from.A"] = "from A!" } # mutable data on A
+    step Nested( B )
+    pass ->(options, **) { options["can.A.see.B.mutable.data?"] = options["mutable.data.from.B"] }
+  end
+
+  #---
+  #- default behavior: share everything.
+  # no containers
+  # no runtime data
+  # no params
+  it do
+    result = A.("params" => {})
+    # everything from A visible
+    result["A.class.data"].       must_equal "yes"
+    result["mutable.data.from.A"].must_equal "from A!"
+
+    # B can see everything
+    result["can.B.see.A.mutable.data?"].must_equal "from A!"
+    result["can.B.see.current_user?"].must_be_nil
+    result["can.B.see.params?"].must_equal({})
+    result["can.B.see.A.class.data?"].must_equal "yes"
+    result["can.B.see.container.data?"].must_be_nil
+
+    result["can.A.see.B.mutable.data?"].must_equal "from B!"
+  end
+
+  #---
+  #- Nested::NonActivity
+  class AlmostB < Trailblazer::Operation
+    step ->(options, is_successful:raise, **) { is_successful } # {AlmostB} fails if {is_successful} isn't true.
+    step ->(options, **) { options["can.B.see.A.mutable.data?"] = options["mutable.data.from.A"] }
+    pass ->(options, **) { options["mutable.data.from.B"]       = "from AlmostB!" }
+  end
+
+  #- Nested( ->{} )
+  class SomeNestedWithProc < Trailblazer::Operation
+    extend ClassDependencies
+    self["A.class.data"] = "yes"                                   # class data on A
+
+    Decider = ->(options, use_class:raise, **) { use_class }
+
+    pass ->(options, **) { options["mutable.data.from.A"] = "from A!" } # mutable data on A
+    step Nested( Decider )
+    pass ->(options, **) { options["can.A.see.B.mutable.data?"] = options["mutable.data.from.B"] }
+  end
+
+  #- Nested( Callable )
+  class SomeNestedWithCallable < Trailblazer::Operation
+    extend ClassDependencies
+    self["A.class.data"] = "yes"                                   # class data on A
+
+    class Decider
+      def self.call(options, use_class:raise, **)
+        use_class
+      end
+    end
+
+    pass ->(options, **) { options["mutable.data.from.A"] = "from A!" } # mutable data on A
+    step Nested( Decider )
+    pass ->(options, **) { options["can.A.see.B.mutable.data?"] = options["mutable.data.from.B"] }
+  end
+
+  #- Nested( :method )
+  class SomeNestedWithMethod < Trailblazer::Operation
+    extend ClassDependencies
+    self["A.class.data"] = "yes"                                   # class data on A
+
+    def decider(options, use_class:raise, **)
+      use_class
+    end
+
+    pass ->(options, **) { options["mutable.data.from.A"] = "from A!" } # mutable data on A
+    step Nested( :decider )
+    pass ->(options, **) { options["can.A.see.B.mutable.data?"] = options["mutable.data.from.B"] }
+  end
+
+
+  #- test callable
+  # B with Callable, successful
+  it do
+    result = SomeNestedWithCallable.("params" => {}, use_class: B)
+    assert_b(result, is_successful: "whatever")
+  end
+
+  # AlmostB with Callable, successful
+  it do
+    result = SomeNestedWithCallable.("params" => {}, use_class: AlmostB, is_successful: true)
+    assert_almost_b(result, is_successful: true)
+  end
+
+  # AlmostB with Callable, failure
+  it do
+    result = SomeNestedWithCallable.("params" => {}, use_class: AlmostB, is_successful: false)
+    assert_almost_b(result, is_successful: false)
+  end
+
+  #- test proc
+  # B with proc, successful
+  it do
+    result = SomeNestedWithProc.("params" => {}, use_class: B)
+    assert_b(result, is_successful: "whatever")
+  end
+
+  # AlmostB with proc, successful
+  it do
+    result = SomeNestedWithProc.("params" => {}, use_class: AlmostB, is_successful: true)
+
+    assert_almost_b(result, is_successful: true)
+  end
+
+  # AlmostB with proc, failure.
+  it do
+    result = SomeNestedWithProc.("params" => {}, use_class: AlmostB, is_successful: false)
+
+    assert_almost_b(result, is_successful: false)
+  end
+
+  #- test :method
+  # B with method, successful
+  it do
+    result = SomeNestedWithMethod.("params" => {}, use_class: B)
+    assert_b(result, is_successful: "whatever")
+  end
+
+  # AlmostB with method, successful
+  it do
+    result = SomeNestedWithMethod.("params" => {}, use_class: AlmostB, is_successful: true)
+
+    assert_almost_b(result, is_successful: true)
+  end
+
+  # AlmostB with method, failure.
+  it do
+    result = SomeNestedWithMethod.("params" => {}, use_class: AlmostB, is_successful: false)
+
+    assert_almost_b(result, is_successful: false)
+  end
+
+
+  def assert_almost_b(result, is_successful:raise)
+    result.success?.must_equal is_successful # AlmostB was successful, so A is successful.
+
+    # everything from A visible
+    result["A.class.data"].       must_equal "yes"
+    result["mutable.data.from.A"].must_equal "from A!"
+
+    # AlmostB doesn't look for everything
+    result["can.B.see.current_user?"].must_be_nil
+    result["can.B.see.params?"].must_be_nil
+    if is_successful
+      result["can.B.see.A.mutable.data?"].must_equal "from A!"
+      result["can.B.see.A.class.data?"].must_equal nil # we don't look for it.
+      result["can.A.see.B.mutable.data?"].must_equal "from AlmostB!"
+    else
+      result["can.B.see.A.mutable.data?"].must_be_nil
+      result["can.B.see.A.class.data?"].must_be_nil
+      result["can.A.see.B.mutable.data?"].must_be_nil
+    end
+    result["can.B.see.container.data?"].must_be_nil
+
+
+    # result[:is_successful].must_equal is_successful # FIXME: this is wrong!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! key is symbol
+  end
+
+  def assert_b(result, is_successful:raise)
+    # everything from A visible
+    result["A.class.data"].       must_equal "yes"
+    result["mutable.data.from.A"].must_equal "from A!"
+
+    # B can see everything
+    result["can.B.see.A.mutable.data?"].must_equal "from A!"
+    result["can.B.see.current_user?"].must_be_nil
+    result["can.B.see.params?"].must_equal({})
+    result["can.B.see.A.class.data?"].must_equal "yes"
+    result["can.B.see.container.data?"].must_be_nil
+
+    result["can.A.see.B.mutable.data?"].must_equal "from B!"
+
+    result[:is_successful].must_be_nil
+    result.success?.must_equal true # B was successful, so A is successful.
+  end
+
+
+  #---
+  #- :exec_context
+  class Create < Trailblazer::Operation
+    class Edit < Trailblazer::Operation
+      step :c!
+
+      def c!(options, **); options[:c] = 1 end
+    end
+
+    step :a!
+    step Nested( Edit )
+    step :b!
+
+    def a!(options, **); options[:a] = 2 end
+    def b!(options, **); options[:b] = 3 end
+  end
+
+  it { Create.().inspect(:a, :b, :c).must_equal %{<Result:true [2, 3, 1] >} }
+end
+
+class NestedWithFastTrackTest < Minitest::Spec
+  module Steps
+    def b(options, a:, **)
+      options["b"] = a+1
+    end
+
+    def f(options, **)
+      options["f"] = 3
+    end
+  end
+
+  class Edit < Trailblazer::Operation
+    pass :a, pass_fast: true
+
+    def a(options, **)
+      options["a"] = 1
+    end
+  end
+
+  class Update < Trailblazer::Operation
+    step Nested( Edit )
+    step :b
+    fail :f
+
+    include Steps
+  end
+
+  # from Nested straight to End.pass_fast.
+  it { Update.({}).inspect("a", "b", "f").must_equal %{<Result:true [1, nil, nil] >} }
+
+  #- Nested, pass_fast: true
+  class Upsert < Trailblazer::Operation
+    step Nested( Edit ), pass_fast: true # this option is unnecessary.
+    step :b
+    fail :f
+
+    include Steps
+  end
+
+  # from Nested straight to End.pass_fast.
+  it { Upsert.({}).inspect("a", "b", "f").must_equal %{<Result:true [1, nil, nil] >} }
+
+  #- mapping
+  #- Nested, :pass_fast => :failure
+  it "attaches :pass_fast => :failure" do
+    op = Class.new(Trailblazer::Operation) do
+      step Nested( Edit ), Output(:pass_fast) => :failure
+      step :b
+      fail :f
+
+      include Steps
+    end
+
+    # from Nested to :failure track.
+    op.({}).inspect("a", "b", "c", "f").must_equal %{<Result:false [1, nil, nil, 3] >}
+  end
+
+  it "goes straigt to End.failure" do
+    op = Class.new(Trailblazer::Operation) do
+      step Nested( Edit ), Output(:pass_fast) => "End.failure"
+      step :b
+      fail :f
+
+      include Steps
+    end
+
+    # from Nested straight to End.failure, no fail step will be visited.
+    op.({}).inspect("a", "b", "c", "f").must_equal %{<Result:false [1, nil, nil, nil] >}
+  end
+end