trailblazer-macro 2.1.0.rc13 → 2.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f650f559c9413f94e4ab3b847052cb86f8893f8e76621ca4f871378ba5459fcc
-  data.tar.gz: 81cd6d65a460a7e5117591a7512490d031fff59fe3599830013fe846dc56104a
+  metadata.gz: 05d8aa98a836c3309c0d44fca95f9bad68c025b7e3358b5e2029ac3f065ad58a
+  data.tar.gz: 9d19baf7edee2388ae99741628729bbafb7d6eb77b09c0baebc19b7e884349f2
 SHA512:
-  metadata.gz: '02853f1b5e504e22ab3ff29506b93b9e02db9834894b8ff6c80dcf35467e5ff6e2f549dc604ba1f18e52a549dd4e7d22d4e229fc09b52f2187bd4859b303257d'
-  data.tar.gz: b3458af49de52c383ad41108989109174d15dbccdea39d4f6a59fde42eb01b29003883022f6e2785fd0d606be1ef90f32780e77498ddd03aa66fc929bbb3574e
+  metadata.gz: d5a1336a619916dc0397595a24671b8c7fcfb765fc39ccdb74a07898bf667b51a808f85cdd595916c0a15db4ffba7103cd2922545ca6d5d432d8015316581990
+  data.tar.gz: d9f939b6d3f3521b255de73efb4a27ce7baa7aadd4a25d7766e5adcf224a6fb0241882736306123f879b8d0821d7710f177eb233e65f39459a5afae5dea6e210

data/.travis.yml

@@ -1,11 +1,12 @@
-sudo: false
 language: ruby
 rvm:
-  - 2.6.2
-  - 2.5.5
-  - 2.4.4
-  - 2.3.7
-  - 2.2
-  - 2.1
-
+  - ruby-head
+  - 2.7
+  - 2.6
+  - 2.5
+  - 2.4
 cache: bundler
+jobs:
+  allow_failures:
+    - rvm: ruby-head
+    - rvm: 2.7

data/CHANGES.md

@@ -1,3 +1,25 @@
+# 2.1.3
+
+* Rename Model()'s `not_found_end` kwarg to `not_found_terminus` for consistency.
+
+# 2.1.2
+
+* Fix to make macros available in all Linear::DSL strategies.
+* Make `params` optional in `Model`.
+* Support for adding `End.not_found` end in `Model`.
+
+# 2.1.1
+
+* Fix case when Macros generate same id due to small entropy
+
+# 2.1.0
+
+* Finally.
+
+# 2.1.0.rc14
+
+* Remove the explicit `dsl-linear` dependency.
+
 # 2.1.0.rc13
 
 * Use symbol keys on `ctx`, only.

data/LICENSE

@@ -0,0 +1,9 @@
+Copyright (c) 2018 Trailblazer GmbH
+
+Trailblazer is an Open Source project licensed under the terms of
+the LGPLv3 license.  Please see <http://www.gnu.org/licenses/lgpl-3.0.html>
+for license text.
+
+Trailblazer PRO has a commercial-friendly license allowing private forks
+and modifications of Trailblazer.  Please see http://trailblazer.to/pro for
+more detail.

data/lib/trailblazer/macro.rb

@@ -1,5 +1,6 @@
+require "forwardable"
 require "trailblazer/activity"
-require "trailblazer/activity/dsl/linear" # TODO: remove this dependency
+require "trailblazer/activity/dsl/linear"
 require "trailblazer/operation" # TODO: remove this dependency
 
 require "trailblazer/macro/model"
@@ -12,18 +13,16 @@ require "trailblazer/macro/wrap"
 
 module Trailblazer
   module Macro
-    # All macros sit in the {Trailblazer::Macro} namespace, where we forward calls from
-    # operations and activities to.
-    def self.forward_macros(target)
-      target.singleton_class.def_delegators Trailblazer::Macro, :Model, :Wrap, :Rescue, :Nested
-      target.const_set(:Policy, Trailblazer::Macro::Policy)
-    end
   end
-end
 
-# TODO: Forwardable.def_delegators(Operation, Macro, :Model, :Wrap) would be amazing. It really sucks to extend a foreign class.
-# Trailblazer::Operation.singleton_class.extend Forwardable
-# Trailblazer::Macro.forward_macros(Trailblazer::Operation)
+  # All macros sit in the {Trailblazer::Macro} namespace, where we forward calls from
+  # operations and activities to.
+  module Activity::DSL::Linear::Helper
+    Policy = Trailblazer::Macro::Policy
 
-Trailblazer::Activity::FastTrack.singleton_class.extend Forwardable
-Trailblazer::Macro.forward_macros(Trailblazer::Activity::FastTrack) # monkey-patching sucks.
+    module ClassMethods
+      extend Forwardable
+      def_delegators Trailblazer::Macro, :Model, :Nested, :Wrap, :Rescue
+    end # ClassMethods
+  end # Helper
+end

data/lib/trailblazer/macro/model.rb

@@ -1,5 +1,8 @@
 module Trailblazer::Macro
-  def self.Model(model_class, action = nil, find_by_key = nil)
+
+  Linear = Trailblazer::Activity::DSL::Linear
+
+  def self.Model(model_class, action = nil, find_by_key = nil, id: 'model.build', not_found_terminus: false)
     task = Trailblazer::Activity::TaskBuilder::Binary(Model.new)
 
     injection = Trailblazer::Activity::TaskWrap::Inject::Defaults::Extension(
@@ -8,11 +11,14 @@ module Trailblazer::Macro
       :"model.find_by_key"    => find_by_key
     )
 
-    {task: task, id: "model.build", extensions: [injection]}
+    options = { task: task, id: id, extensions: [injection] }
+    options = options.merge(Linear::Output(:failure) => Linear::End(:not_found)) if not_found_terminus
+
+    options
   end
 
   class Model
-    def call(options, params:,  **)
+    def call(options, params: nil,  **)
       builder                 = Model::Builder.new
       options[:model]         = model = builder.call(options, params)
       options[:"result.model"] = result = Trailblazer::Operation::Result.new(!model.nil?, {})

data/lib/trailblazer/macro/rescue.rb

@@ -20,7 +20,7 @@ module Trailblazer
         end
       end
 
-      Wrap(rescue_block, id: "Rescue(#{rand(100)})", &block)
+      Wrap(rescue_block, id: "Rescue(#{SecureRandom.hex(4)})", &block)
       # FIXME: name
       # [ step, name: "Rescue:#{block.source_location.last}" ]
     end

data/lib/trailblazer/macro/version.rb

@@ -1,7 +1,7 @@
 module Trailblazer
   module Version
     module Macro
-      VERSION = "2.1.0.rc13".freeze
+      VERSION = "2.1.3"
     end
   end
 end

data/lib/trailblazer/macro/wrap.rb

@@ -1,6 +1,8 @@
+require 'securerandom'
+
 module Trailblazer
   module Macro
-    def self.Wrap(user_wrap, id: "Wrap/#{rand(100)}", &block)
+    def self.Wrap(user_wrap, id: "Wrap/#{SecureRandom.hex(4)}", &block)
       activity = Class.new(Activity::FastTrack, &block) # This is currently coupled to {dsl-linear}.
 
       outputs  = activity.to_h[:outputs]

data/test/docs/guard_test.rb

@@ -6,13 +6,13 @@ class DocsGuardProcTest < Minitest::Spec
   #:proc
   class Create < Trailblazer::Operation
     step Policy::Guard(->(options, pass:, **) { pass })
-    #~pipeonly
+    #:pipeonly
     step :process
 
     def process(options, **)
       options[:x] = true
     end
-    #~pipeonly end
+    #:pipeonly end
   end
   #:proc end
 
@@ -46,13 +46,15 @@ class DocsGuardTest < Minitest::Spec
   #:callable-op
   class Create < Trailblazer::Operation
     step Policy::Guard( MyGuard.new )
-    #~pipe-only
+    #:pipe-only
     step :process
 
+    #~methods
     def process(options, **)
       options[:x] = true
     end
-    #~pipe-only end
+    #~methods end
+    #:pipe-only end
   end
   #:callable-op end
 
@@ -72,10 +74,11 @@ class DocsGuardMethodTest < Minitest::Spec
     end
     #~pipe-onlyy
     step :process
-
+    #~methods
     def process(options, **)
       options[:x] = true
     end
+    #~methods end
     #~pipe-onlyy end
   end
   #:method end

data/test/docs/model_test.rb

@@ -45,6 +45,13 @@ class DocsModelTest < Minitest::Spec
   end
   #:update-with-find-by-key end
 
+  #:update-with-not-found-end
+  class UpdateFailureWithModelNotFound < Trailblazer::Operation
+    step Model( Song, :find_by, not_found_terminus: true )
+    # ..
+  end
+  #:update-with-not-found-end end
+
   it do
     #:update-ok
     result = Update.(params: { id: 1 })
@@ -83,6 +90,19 @@ class DocsModelTest < Minitest::Spec
     result.success?.must_equal false
   end
 
+  it do
+    #:update-with-not-found-end-use
+    result = UpdateFailureWithModelNotFound.(params: {title: nil})
+    result[:model] #=> nil
+    result.success? #=> false
+    result.event #=> #<Trailblazer::Activity::End semantic=:not_found>
+    #:update-with-not-found-end-use end
+
+    result[:model].must_be_nil
+    result.success?.must_equal false
+    result.event.inspect.must_equal %{#<Trailblazer::Activity::End semantic=:not_found>}
+  end
+
   #:show
   class Show < Trailblazer::Operation
     step Model( Song, :[] )

data/test/docs/nested_test.rb

@@ -16,22 +16,33 @@ class NestedInput < Minitest::Spec
     end
   end
 
-  it "Nested(Edit), without any options" do
-    edit = self.edit
-
-    create = Class.new(Trailblazer::Operation) do
-      step :a
-      step Nested( edit )
-      step :b
-
-      include T.def_steps(:a, :b)
-    end
+  class Validate < Trailblazer::Operation
+    step :validate
+    # ... more steps ...
+    include T.def_steps(:validate)
+  end
 
-    # this will print a DEPRECATION warning.
-  # success
-    create.(seq: []).inspect(:seq).must_equal %{<Result:true [[:a, :c, :b]] >}
-  # failure in Nested
-    create.(seq: [], c: false).inspect(:seq).must_equal %{<Result:false [[:a, :c]] >}
+  it "Nested(Edit), without any options" do
+      module A
+
+        create =
+        #:nested
+        class Create < Trailblazer::Operation
+          step :create
+          step Nested(Validate)
+          step :save
+          #~meths
+          include T.def_steps(:create, :save)
+          #~meths end
+        end
+        #:nested end
+
+        # this will print a DEPRECATION warning.
+      # success
+        create.(seq: []).inspect(:seq).must_equal %{<Result:true [[:create, :validate, :save]] >}
+      # failure in Nested
+        create.(seq: [], validate: false).inspect(:seq).must_equal %{<Result:false [[:create, :validate]] >}
+      end
   end
 
   it "Nested(Edit), with Output rewiring" do
@@ -52,32 +63,102 @@ class NestedInput < Minitest::Spec
   end
 
   it "Nested(:method)" do
-    create = Class.new(Trailblazer::Operation) do
-      step :a
-      step Nested(:compute_edit)
-      step :b
-
-      def compute_edit(ctx, what:, **)
-        what
+    module B
+      create =
+      #:nested-dynamic
+      class Create < Trailblazer::Operation
+        step :create
+        step Nested(:compute_nested)
+        step :save
+
+        def compute_nested(ctx, params:, **)
+          params.is_a?(Hash) ? Validate : JsonValidate
+        end
+        #~meths
+        include T.def_steps(:create, :save)
+        #~meths end
       end
+      #:nested-dynamic end
 
-      include T.def_steps(:a, :b)
-    end
-
+      class JsonValidate < Validate
+        step :json
+        include T.def_steps(:json)
+      end
     # `edit` and `update` can be called from Nested()
 
   # edit/success
-    create.(seq: [], what: edit).inspect(:seq).must_equal %{<Result:true [[:a, :c, :b]] >}
+    create.(seq: [], params: {}).inspect(:seq).must_equal %{<Result:true [[:create, :validate, :save]] >}
 
   # update/success
-    create.(seq: [], what: update).inspect(:seq).must_equal %{<Result:true [[:a, :d, :b]] >}
+    create.(seq: [], params: nil).inspect(:seq).must_equal %{<Result:true [[:create, :validate, :json, :save]] >}
 
 
 # wiring of fail:
   # edit/failure
-    create.(seq: [], what: edit, c: false).inspect(:seq).must_equal %{<Result:false [[:a, :c]] >}
+    create.(seq: [], params: {}, validate: false).inspect(:seq).must_equal %{<Result:false [[:create, :validate]] >}
   # update/failure
-    create.(seq: [], what: update, d: false).inspect(:seq).must_equal %{<Result:false [[:a, :d]] >}
+    create.(seq: [], params: nil, json: false).inspect(:seq).must_equal %{<Result:false [[:create, :validate, :json]] >}
+    end
+  end
+
+  it "Nested(:method), input: :my_input" do
+    module C
+      #:nested-dynamic
+      class Create < Trailblazer::Operation
+        step :create
+        step Nested(:compute_nested), input: ->(ctx, *) {{foo: :bar, seq: ctx[:seq]}}
+        step :save
+
+        def compute_nested(ctx, params:, **)
+          params.is_a?(Hash) ? Validate : JsonValidate
+        end
+
+        #~meths
+        include T.def_steps(:create, :save)
+        #~meths end
+      end
+      #:nested-dynamic end
+
+      class JsonValidate < Validate
+        step :json
+        include T.def_steps(:json)
+      end
+
+    # `edit` and `update` can be called from Nested()
+    end
+
+    C::Create.(seq: [], params: {}).inspect(:seq).must_equal %{<Result:true [[:create, :validate, :save]] >}
+    C::Create.(seq: [], params: nil).inspect(:seq).must_equal %{<Result:true [[:create, :validate, :json, :save]] >}
+  end
+
+  it "Nested(:method), with pass_fast returned from nested" do
+    class JustPassFast < Trailblazer::Operation
+      step :just_pass_fast, pass_fast: true
+      include T.def_steps(:just_pass_fast)
+    end
+
+    module D
+
+      create =
+      #:nested-with-pass-fast
+      class Create < Trailblazer::Operation
+
+        def compute_nested(ctx, **)
+          JustPassFast
+        end
+
+        step :create
+        step Nested(:compute_nested)
+        step :save
+        #~meths
+        include T.def_steps(:create, :save)
+        #~meths end
+      end
+      #:nested-with-pass-fast end
+
+      # pass fast
+      create.(seq: []).inspect(:seq).must_equal %{<Result:true [[:create, :just_pass_fast, :save]] >}
+    end
   end
 
   let(:compute_edit) {

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
 

data/test/test_helper.rb

@@ -1,9 +1,10 @@
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+require "trailblazer/macro"
+
 require "delegate" # Ruby 2.2
 require "minitest/autorun"
 
 require "trailblazer/developer"
-require "trailblazer/macro"
-
 
 module Mock
   class Result
@@ -39,7 +40,7 @@ T = Trailblazer::Activity::Testing
 module Rehash
   def rehash(ctx, seq:, rehash_raise: false, **)
     seq << :rehash
-    raise if rehash_raise
+    raise "nope!" if rehash_raise
     true
   end
 end

data/trailblazer-macro.gemspec

@@ -10,7 +10,7 @@ Gem::Specification.new do |spec|
   spec.description   = "Macros for Trailblazer's operation"
   spec.summary       = "Macros for Trailblazer's operation: Policy, Wrap, Rescue and more."
   spec.homepage      = "http://trailblazer.to"
-  spec.license       = "MIT"
+  spec.license       = "LGPL-3.0"
 
   spec.files         = `git ls-files`.split($INPUT_RECORD_SEPARATOR)
   spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
@@ -18,9 +18,6 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
 
   spec.add_development_dependency "bundler"
-
-  # spec.add_development_dependency "trailblazer-operation", ">= 0.4.1", "< 0.5.0"
-
   spec.add_development_dependency "minitest"
   spec.add_development_dependency "rake"
 
@@ -28,8 +25,9 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "roar"
   spec.add_development_dependency "trailblazer-developer"
 
-  spec.add_dependency "trailblazer-activity-dsl-linear", ">= 0.1.6", "< 0.2.0"  # TODO: this dependency will be removed.
-  spec.add_dependency "trailblazer-operation", ">= 0.5.2" # TODO: this dependency will be removed.
+  spec.add_dependency "trailblazer-activity", ">= 0.10.0", "< 1.0.0"
+  spec.add_dependency "trailblazer-activity-dsl-linear", ">= 0.2.7", "< 1.0.0"
+  spec.add_dependency "trailblazer-operation", ">= 0.6.2" # TODO: this dependency will be removed.
 
-  spec.required_ruby_version = ">= 2.0.0"
+  spec.required_ruby_version = ">= 2.2.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: trailblazer-macro
 version: !ruby/object:Gem::Version
-  version: 2.1.0.rc13
+  version: 2.1.3
 platform: ruby
 authors:
 - Nick Sutterer
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-07-24 00:00:00.000000000 Z
+date: 2020-07-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -95,40 +95,60 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: trailblazer-activity
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.10.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.10.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 1.0.0
 - !ruby/object:Gem::Dependency
   name: trailblazer-activity-dsl-linear
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.1.6
+        version: 0.2.7
     - - "<"
       - !ruby/object:Gem::Version
-        version: 0.2.0
+        version: 1.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.1.6
+        version: 0.2.7
     - - "<"
       - !ruby/object:Gem::Version
-        version: 0.2.0
+        version: 1.0.0
 - !ruby/object:Gem::Dependency
   name: trailblazer-operation
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.5.2
+        version: 0.6.2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.5.2
+        version: 0.6.2
 description: Macros for Trailblazer's operation
 email:
 - apotonick@gmail.com
@@ -143,7 +163,7 @@ files:
 - ".travis.yml"
 - CHANGES.md
 - Gemfile
-- LICENSE.txt
+- LICENSE
 - README.md
 - Rakefile
 - lib/trailblazer-macro.rb
@@ -170,7 +190,7 @@ files:
 - trailblazer-macro.gemspec
 homepage: http://trailblazer.to
 licenses:
-- MIT
+- LGPL-3.0
 metadata: {}
 post_install_message: 
 rdoc_options: []
@@ -180,15 +200,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.0.0
+      version: 2.2.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.6
+rubygems_version: 3.0.8
 signing_key: 
 specification_version: 4
 summary: 'Macros for Trailblazer''s operation: Policy, Wrap, Rescue and more.'

data/LICENSE.txt

@@ -1,27 +0,0 @@
-The MIT License (MIT)
-
-Copyright (c) 2018 Trailblazer GmbH
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
-
----------
-
-Trailblazer Enterprise has a commercial-friendly license allowing private forks
-and modifications of Trailblazer.  Please see http://trailblazer.to/enterprise/ for
-more detail.