trailblazer-macro 2.1.0.rc12 → 2.1.2

data/test/docs/pundit_test.rb

@@ -36,11 +36,11 @@ class DocsPunditProcTest < Minitest::Spec
   it do
   #:pundit-result
   result = Create.(params: {}, current_user: Module)
-  result["result.policy.default"].success? #=> true
-  result["result.policy.default"]["policy"] #=> #<MyPolicy ...>
+  result[:"result.policy.default"].success? #=> true
+  result[:"result.policy.default"][:policy] #=> #<MyPolicy ...>
   #:pundit-result end
-    result["result.policy.default"].success?.must_equal true
-    result["result.policy.default"]["policy"].is_a?(MyPolicy).must_equal true
+    result[:"result.policy.default"].success?.must_equal true
+    result[:"result.policy.default"][:policy].is_a?(MyPolicy).must_equal true
   end
 
   #---
@@ -82,7 +82,7 @@ class DocsPunditProcTest < Minitest::Spec
   #:di-call
   Create.(params: {},
     current_user:            Module,
-    "policy.default.eval" => Trailblazer::Operation::Policy::Pundit.build(AnotherPolicy, :create?)
+    :"policy.default.eval" => Trailblazer::Operation::Policy::Pundit.build(AnotherPolicy, :create?)
   )
   #:di-call end
     result.inspect("").must_equal %{<Result:true [nil] >} }
@@ -104,9 +104,9 @@ class PunditWithNameTest < Minitest::Spec
   it {
   #:name-call
   result = Create.(params: {}, current_user: Module)
-  result["result.policy.after_model"].success? #=> true
+  result[:"result.policy.after_model"].success? #=> true
   #:name-call end
-    result["result.policy.after_model"].success?.must_equal true }
+    result[:"result.policy.after_model"].success?.must_equal true }
 end
 
 #---

data/test/docs/rescue_test.rb

@@ -23,7 +23,7 @@ class NestedRescueTest < Minitest::Spec
     fail ->(options, **) { options["outer-err"] = true }, id: "nested/failure"
   end
 
-  it { Trailblazer::Developer.railway(NestedInsanity).must_match /\[>Rescue\(\d+\),>nested/ } # FIXME: better introspect tests for all id-generating macros.
+  it { Trailblazer::Developer.railway(NestedInsanity).must_match /\[>Rescue\(.{8}\),>nested/ } # FIXME: better introspect tests for all id-generating macros.
   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] >} }

data/test/docs/wrap_test.rb

@@ -1,9 +1,6 @@
 require "test_helper"
 
 class DocsWrapTest < Minitest::Spec
-  module Memo
-  end
-
 =begin
 When success: return the block's returns
 When raise:   return {Railway.fail!}
@@ -11,11 +8,10 @@ When raise:   return {Railway.fail!}
   #:wrap-handler
   class HandleUnsafeProcess
     def self.call((ctx, flow_options), *, &block)
-      begin
-        yield # calls the wrapped steps
-      rescue
-        [ Trailblazer::Operation::Railway.fail!, [ctx, flow_options] ]
-      end
+      yield # calls the wrapped steps
+    rescue
+      ctx[:exception] = $!.message
+      [ Trailblazer::Operation::Railway.fail!, [ctx, flow_options] ]
     end
   end
   #:wrap-handler end
@@ -64,6 +60,11 @@ result.wtf? #=>
 =end
   end
 
+=begin
+Writing into ctx in a Wrap()
+=end
+  it { Memo::Create.( { seq: [], rehash_raise: true } )[:exception].must_equal("nope!") }
+
 =begin
 When success: return the block's returns
 When raise:   return {Railway.fail!}, but wire Wrap() to {fail_fast: true}
@@ -74,13 +75,9 @@ When raise:   return {Railway.fail!}, but wire Wrap() to {fail_fast: true}
     class Memo::Create < Trailblazer::Operation
       class HandleUnsafeProcess
         def self.call((ctx), *, &block)
-          begin
-            yield # calls the wrapped steps
-          rescue
-            puts $!
-            ctx[:exception] = $!.message
-            [ Trailblazer::Operation::Railway.fail!, [ctx, {}] ]
-          end
+          yield # calls the wrapped steps
+        rescue
+          [ Trailblazer::Operation::Railway.fail!, [ctx, {}] ]
         end
       end
 
@@ -112,11 +109,9 @@ When raise:   return {Railway.fail_fast!} and configure Wrap() to {fast_track: t
     #:fail-fast-handler
     class HandleUnsafeProcess
       def self.call((ctx), *, &block)
-        begin
-          yield # calls the wrapped steps
-        rescue
-          [ Trailblazer::Operation::Railway.fail_fast!, [ctx, {}] ]
-        end
+        yield # calls the wrapped steps
+      rescue
+        [ Trailblazer::Operation::Railway.fail_fast!, [ctx, {}] ]
       end
     end
     #:fail-fast-handler end
@@ -145,120 +140,176 @@ When raise:   return {Railway.fail_fast!} and configure Wrap() to {fast_track: t
 When success: return the block's returns
 When raise:   return {Railway.fail!} or {Railway.pass!}
 =end
-  class WrapWithTransactionTest < Minitest::Spec
-    Memo = Module.new
+  class WrapWithCustomEndsTest < Minitest::Spec
+    Memo   = Module.new
 
-    module Sequel
-      def self.transaction
-        begin
-          end_event, (ctx, flow_options) = yield
-          true
-        rescue
-          false
-        end
+    #:custom-handler
+    class MyTransaction
+      MyFailSignal = Class.new(Trailblazer::Activity::Signal)
+
+      def self.call((ctx, flow_options), *, &block)
+        yield # calls the wrapped steps
+      rescue
+        MyFailSignal
       end
     end
+    #:custom-handler end
 
-    #:transaction-handler
-    class MyTransaction
-      def self.call((ctx, flow_options), *, &block)
-        result = Sequel.transaction { yield }
+    #:custom
+    class Memo::Create < Trailblazer::Operation
+      step :find_model
+      step Wrap( MyTransaction ) {
+        step :update
+        step :rehash
+      },
+        Output(:success) => End(:transaction_worked),
+        Output(MyTransaction::MyFailSignal, :failure) => End(:transaction_failed)
+      step :notify
+      fail :log_error
+      #~methods
+      include T.def_steps(:find_model, :update, :notify, :log_error)
+      include Rehash
+      #~methods end
+    end
+    #:custom end
 
-        signal = result ? Trailblazer::Operation::Railway.pass! : Trailblazer::Operation::Railway.fail!
+    it do
+      result = Memo::Create.( { seq: [] } )
+      result.inspect(:seq).must_equal %{<Result:false [[:find_model, :update, :rehash]] >}
+      result.event.inspect.must_equal %{#<Trailblazer::Activity::End semantic=:transaction_worked>}
+    end
 
-        [ signal, [ctx, flow_options] ]
-      end
+    it do
+      result = Memo::Create.( { seq: [], rehash_raise: true } )
+      result.inspect(:seq).must_equal %{<Result:false [[:find_model, :update, :rehash]] >}
+      result.event.inspect.must_equal %{#<Trailblazer::Activity::End semantic=:transaction_failed>}
     end
-    #:transaction-handler end
+  end
+
+=begin
+When success: return the block's returns
+When raise:   return {Railway.pass!} and go "successful"
+=end
+  class WrapGoesIntoPassFromRescueTest < Minitest::Spec
+    Memo = Module.new
 
-    #:transaction
     class Memo::Create < Trailblazer::Operation
+      class HandleUnsafeProcess
+        def self.call((ctx), *, &block)
+          yield # calls the wrapped steps
+        rescue
+          [ Trailblazer::Operation::Railway.pass!, [ctx, {}] ]
+        end
+      end
+
       step :find_model
-      step Wrap( MyTransaction ) {
+      step Wrap( HandleUnsafeProcess ) {
         step :update
         step :rehash
       }
       step :notify
       fail :log_error
+
       #~methods
       include T.def_steps(:find_model, :update, :notify, :log_error)
       include Rehash
       #~methods end
     end
-    #:transaction end
 
     it { Memo::Create.( { seq: [] } ).inspect(:seq).must_equal %{<Result:true [[:find_model, :update, :rehash, :notify]] >} }
-    it { Memo::Create.( { seq: [], rehash_raise: true } ).inspect(:seq).must_equal %{<Result:false [[:find_model, :update, :rehash, :log_error]] >} }
+    it { Memo::Create.( { seq: [], rehash_raise: true } ).inspect(:seq).must_equal %{<Result:true [[:find_model, :update, :rehash, :notify]] >} }
   end
 
 =begin
 When success: return the block's returns
-When raise:   return {Railway.fail!} or {Railway.pass!}
+When raise:   return {true} and go "successful"
+You can return boolean true in wrap.
 =end
-  class WrapWithCustomEndsTest < Minitest::Spec
-    Memo   = Module.new
-    Sequel = WrapWithTransactionTest::Sequel
+  class WrapGoesIntoBooleanTrueFromRescueTest < Minitest::Spec
+    Memo = Module.new
 
-    #:custom-handler
-    class MyTransaction
-      MyFailSignal = Class.new(Trailblazer::Activity::Signal)
+    class Memo::Create < Trailblazer::Operation
+      class HandleUnsafeProcess
+        def self.call((ctx), *, &block)
+          yield # calls the wrapped steps
+        rescue
+          true
+        end
+      end
 
-      def self.call((ctx, flow_options), *, &block)
-        result = Sequel.transaction { yield }
+      step :find_model
+      step Wrap( HandleUnsafeProcess ) {
+        step :update
+        step :rehash
+      }
+      step :notify
+      fail :log_error
 
-        signal = result ? Trailblazer::Operation::Railway.pass! : MyFailSignal
+      #~methods
+      include T.def_steps(:find_model, :update, :notify, :log_error)
+      include Rehash
+      #~methods end
+    end
 
-        [ signal, [ctx, flow_options] ]
-      end
+    it "translates true returned form a wrap to a signal with a `success` semantic" do
+      result = Memo::Create.( { seq: [], rehash_raise: true } )
+      result.inspect(:seq).must_equal %{<Result:true [[:find_model, :update, :rehash, :notify]] >}
+      result.event.inspect.must_equal %{#<Trailblazer::Activity::Railway::End::Success semantic=:success>}
     end
-    #:custom-handler end
+  end
+
+=begin
+When success: return the block's returns
+When raise:   return {false} and go "failed"
+You can return boolean false in wrap.
+=end
+  class WrapGoesIntoBooleanFalseFromRescueTest < Minitest::Spec
+    Memo = Module.new
 
-    #:custom
     class Memo::Create < Trailblazer::Operation
+      class HandleUnsafeProcess
+        def self.call((ctx), *, &block)
+          yield # calls the wrapped steps
+        rescue
+          false
+        end
+      end
+
       step :find_model
-      step Wrap( MyTransaction ) {
+      step Wrap( HandleUnsafeProcess ) {
         step :update
         step :rehash
-      },
-        Output(:success) => End(:transaction_worked),
-        Output(MyTransaction::MyFailSignal, :failure) => End(:transaction_failed)
+      }
       step :notify
       fail :log_error
+
       #~methods
       include T.def_steps(:find_model, :update, :notify, :log_error)
       include Rehash
       #~methods end
     end
-    #:custom end
-
-    it do
-      result = Memo::Create.( { seq: [] } )
-      result.inspect(:seq).must_equal %{<Result:false [[:find_model, :update, :rehash]] >}
-      result.event.inspect.must_equal %{#<Trailblazer::Activity::End semantic=:transaction_worked>}
-    end
 
-    it do
+    it "translates false returned form a wrap to a signal with a `failure` semantic" do
       result = Memo::Create.( { seq: [], rehash_raise: true } )
-      result.inspect(:seq).must_equal %{<Result:false [[:find_model, :update, :rehash]] >}
-      result.event.inspect.must_equal %{#<Trailblazer::Activity::End semantic=:transaction_failed>}
+      result.inspect(:seq).must_equal %{<Result:false [[:find_model, :update, :rehash, :log_error]] >}
+      result.event.inspect.must_equal %{#<Trailblazer::Activity::Railway::End::Failure semantic=:failure>}
     end
   end
 
 =begin
 When success: return the block's returns
-When raise:   return {Railway.pass!} and go "successful"
+When raise:   return {nil} and go "failed"
+You can return nil in wrap.
 =end
-  class WrapGoesIntoPassFromRescueTest < Minitest::Spec
+  class WrapGoesIntoNilFromRescueTest < Minitest::Spec
     Memo = Module.new
 
     class Memo::Create < Trailblazer::Operation
       class HandleUnsafeProcess
         def self.call((ctx), *, &block)
-          begin
-            yield # calls the wrapped steps
-          rescue
-            [ Trailblazer::Operation::Railway.pass!, [ctx, {}] ]
-          end
+          yield # calls the wrapped steps
+        rescue
+          nil
         end
       end
 
@@ -276,7 +327,94 @@ When raise:   return {Railway.pass!} and go "successful"
       #~methods end
     end
 
+    it "translates nil returned form a wrap to a signal with a `failure` semantic" do
+      result = Memo::Create.( { seq: [], rehash_raise: true } )
+      result.inspect(:seq).must_equal %{<Result:false [[:find_model, :update, :rehash, :log_error]] >}
+      result.event.inspect.must_equal %{#<Trailblazer::Activity::Railway::End::Failure semantic=:failure>}
+    end
+  end
+
+=begin
+When success: return the block's returns
+When raise:   return {Railway.fail!}
+This one is mostly to show how one could wrap steps in a transaction
+=end
+  class WrapWithTransactionTest < Minitest::Spec
+    Memo = Module.new
+
+    module Sequel
+      def self.transaction
+        end_event, (ctx, flow_options) = yield
+      end
+    end
+
+    #:transaction-handler
+    class MyTransaction
+      def self.call((ctx, flow_options), *, &block)
+        Sequel.transaction { yield } # calls the wrapped steps
+      rescue
+        [ Trailblazer::Operation::Railway.fail!, [ctx, flow_options] ]
+      end
+    end
+    #:transaction-handler end
+
+    #:transaction
+    class Memo::Create < Trailblazer::Operation
+      step :find_model
+      step Wrap( MyTransaction ) {
+        step :update
+        step :rehash
+      }
+      step :notify
+      fail :log_error
+      #~methods
+      include T.def_steps(:find_model, :update, :notify, :log_error)
+      include Rehash
+      #~methods end
+    end
+    #:transaction end
+
     it { Memo::Create.( { seq: [] } ).inspect(:seq).must_equal %{<Result:true [[:find_model, :update, :rehash, :notify]] >} }
-    it { Memo::Create.( { seq: [], rehash_raise: true } ).inspect(:seq).must_equal %{<Result:true [[:find_model, :update, :rehash, :notify]] >} }
+    it { Memo::Create.( { seq: [], rehash_raise: true } ).inspect(:seq).must_equal %{<Result:false [[:find_model, :update, :rehash, :log_error]] >} }
+  end
+
+=begin
+When success: return {Railway.pass_fast!}
+When failure: return {Railway.fail!}
+This one is mostly to show how one could evaluate Wrap()'s return value based on Wrap() block's return
+=end
+  class WrapWithBlockReturnSignatureCheckTest < Minitest::Spec
+    Memo = Module.new
+
+    #:handler-with-signature-evaluator
+    class HandleUnsafeProcess
+      def self.call((_ctx, _flow_options), *, &block)
+        signal, (ctx, flow_options) = yield
+        evaluated_signal = if signal.to_h[:semantic] == :success
+                            Trailblazer::Operation::Railway.pass_fast!
+                          else
+                            Trailblazer::Operation::Railway.fail!
+                          end
+        [ evaluated_signal, [ctx, flow_options] ]
+      end
+    end
+    #:handler-with-signature-evaluator end
+
+    #:transaction
+    class Memo::Create < Trailblazer::Operation
+      step :find_model
+      step Wrap( HandleUnsafeProcess ) {
+        step :update
+      }, fast_track: true # because Wrap can return pass_fast! now
+      step :notify
+      fail :log_error
+      #~methods
+      include T.def_steps(:find_model, :update, :notify, :log_error)
+      #~methods end
+    end
+    #:transaction end
+
+    it { Memo::Create.( { seq: [] } ).inspect(:seq).must_equal %{<Result:true [[:find_model, :update]] >} }
+    it { Memo::Create.( { seq: [], update: false } ).inspect(:seq).must_equal %{<Result:false [[:find_model, :update, :log_error]] >} }
   end
 end

data/test/operation/model_test.rb

@@ -19,11 +19,8 @@ class ModelTest < Minitest::Spec
   end
 
   # :new new.
-  it { Create.(params: {})[:model].inspect.must_equal %{#<struct ModelTest::Song id=nil, title=nil>} }
-  it do
-
-    result = Create.(params: {})
-
+  it "initializes new model's instance" do
+    result = Create.()
     result[:model].inspect.must_equal %{#<struct ModelTest::Song id=nil, title=nil>}
   end
 
@@ -48,7 +45,7 @@ class ModelTest < Minitest::Spec
     step Trailblazer::Operation::Model Song, :find_by
     step :process
 
-    def process(options, **); options["x"] = true end
+    def process(options, **); options[:x] = true end
   end
 
   # :find_by, exceptionless.
@@ -57,36 +54,36 @@ class ModelTest < Minitest::Spec
     step Trailblazer::Operation::Model( Song, :find_by, :title )
     step :process
 
-    def process(options, **); options["x"] = true end
+    def process(options, **); options[:x] = true end
   end
 
   # can't find model.
   #- result object, model
   it do
-    Find.(params: {id: nil})["result.model"].failure?.must_equal true
-    Find.(params: {id: nil})["x"].must_be_nil
+    Find.(params: {id: nil})[:"result.model"].failure?.must_equal true
+    Find.(params: {id: nil})[:"x"].must_be_nil
     Find.(params: {id: nil}).failure?.must_equal true
   end
 
   #- result object, model
   it do
-    Find.(params: {id: 9})["result.model"].success?.must_equal true
-    Find.(params: {id: 9})["x"].must_equal true
+    Find.(params: {id: 9})[:"result.model"].success?.must_equal true
+    Find.(params: {id: 9})[:"x"].must_equal true
     Find.(params: {id: 9})[:model].inspect.must_equal %{#<struct ModelTest::Song id=9, title=nil>}
   end
 
   # can't find model by title.
   #- result object, model
   it do
-    FindByKey.(params: {title: nil})["result.model"].failure?.must_equal true
-    FindByKey.(params: {title: nil})["x"].must_be_nil
+    FindByKey.(params: {title: nil})[:"result.model"].failure?.must_equal true
+    FindByKey.(params: {title: nil})[:"x"].must_be_nil
     FindByKey.(params: {title: nil}).failure?.must_equal true
   end
 
   #- result object, model by title
   it do
-    FindByKey.(params: {title: "Test"})["result.model"].success?.must_equal true
-    FindByKey.(params: {title: "Test"})["x"].must_equal true
+    FindByKey.(params: {title: "Test"})[:"result.model"].success?.must_equal true
+    FindByKey.(params: {title: "Test"})[:"x"].must_equal true
     FindByKey.(params: {title: "Test"})[:model].inspect.must_equal %{#<struct ModelTest::Song id=2, title="Test">}
   end
 end