trailblazer-macro 2.1.1 → 2.1.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 120b5d524c120b02535b2bb0f35a1064473682d62067f2c438e527e2f3ff5fe2
-  data.tar.gz: 8c385fd83b0b9770718a5bb9816ba0dd4f92ff68807eee2719b2087d33ae9846
+  metadata.gz: d789d88096949c41a15147feed363efab5c86e586b4f76c819e12f6e8f2d4a70
+  data.tar.gz: fbe7775b4330bc7b607058da66c896fe461e73b1337e747c23eb87acb04b8d30
 SHA512:
-  metadata.gz: 2ce693a9d6a46bdebdd23fcf46807b8d1c4054ca31038114bfe9e9ffdd294f33bff5f98a6877d7be17bd69f7b821715dff2d954c7aca719fb4584cd93c43c6fa
-  data.tar.gz: 56ab8bd84575cfd7f4fcc1cf82a8fac977532de8003ff6efdbfa91ed14179b28ea50cb2bf512e8ef376a6f41c98b528e44dbb524dc0e7ad208e40f91e1b3672a
+  metadata.gz: df7f0de0c1107ea8c9b3803e8343907c0deb78e943ac2298a114db9fedb6de88252f5055a247b516fa3c80a2432f52913fd6d84ceb189779b58c87da6204a20f
+  data.tar.gz: a1e7a11851d02b26badfbff8aa6932810bc2e32ae3d1f4ce5fd73f2bf26284bff62a88b1fd27d29f5b82a7962e61fd0655b97f483483ff6df5cffdb3326f51e0

data/.github/workflows/ci.yml

@@ -0,0 +1,17 @@
+name: CI
+on: [push, pull_request]
+jobs:
+  test:
+    strategy:
+      fail-fast: false
+      matrix:
+        # Due to https://github.com/actions/runner/issues/849, we have to use quotes for '3.0'
+        ruby: [2.5, 2.6, 2.7, '3.0', head, jruby, jruby-head]
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v2
+    - uses: ruby/setup-ruby@v1
+      with:
+        ruby-version: ${{ matrix.ruby }}
+        bundler-cache: true # runs 'bundle install' and caches installed gems automatically
+    - run: bundle exec rake

data/CHANGES.md

@@ -1,3 +1,26 @@
+# 2.1.6
+
+* Allow connecting ends of the dynamically selected activity for `Nested()` using `:auto_wire`.
+
+# 2.1.5
+
+* Support for Ruby 3.0.
+
+# 2.1.4
+
+* Upgrade DSL version to fix step's circuit interface eating passed arguments
+* Upgrade OP version to remove OP::Container reference in tests
+
+# 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

data/Gemfile

@@ -5,11 +5,11 @@ gemspec
 
 # gem "trailblazer", github: "trailblazer/trailblazer"
 # gem "trailblazer-activity", path: "../trailblazer-activity"
-# gem "trailblazer-activity-dsl-linear", github: "trailblazer/trailblazer-activity-dsl-linear", branch: 'master'
 # gem "trailblazer-activity-dsl-linear", path: "../trailblazer-activity-dsl-linear"
-# gem "trailblazer-operation", github: "trailblazer/trailblazer-operation", branch: 'linear'
-# gem "trailblazer-activity"#, github: "trailblazer/trailblazer-activity"
 # gem "trailblazer-macro-contract", git: "https://github.com/trailblazer/trailblazer-macro-contract"
+# gem "trailblazer-context", path: "../trailblazer-context"
+# gem "trailblazer-operation", path: "../trailblazer-operation"
+
 
 gem "minitest-line"
 gem "rubocop", require: false

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/guard.rb

@@ -6,11 +6,11 @@ module Trailblazer::Macro
 
     module Guard
       def self.build(callable)
-        option = Trailblazer::Option::KW(callable)
+        option = Trailblazer::Option(callable)
 
         # this gets wrapped in a Operation::Result object.
-        ->((options, *), circuit_args) do
-          Trailblazer::Operation::Result.new(!!option.call(options, circuit_args), {})
+        ->((ctx, *), **circuit_args) do
+          Trailblazer::Operation::Result.new(!!option.call(ctx, keyword_arguments: ctx.to_hash, **circuit_args), {})
         end
       end
     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/nested.rb

@@ -2,14 +2,14 @@
 module Trailblazer
   module Macro
     # {Nested} macro.
-    def self.Nested(callable, id: "Nested(#{callable})")
+    def self.Nested(callable, id: "Nested(#{callable})", auto_wire: [])
       if callable.is_a?(Class) && callable < Nested.operation_class
         warn %{[Trailblazer] Using the `Nested()` macro with operations and activities is deprecated. Replace `Nested(Create)` with `Subprocess(Create)`.}
         return Nested.operation_class.Subprocess(callable)
       end
 
       # dynamic
-      task = Nested::Dynamic.new(callable)
+      task = Nested::Dynamic.new(callable, auto_wire: auto_wire)
 
       merge = [
         [Activity::TaskWrap::Pipeline.method(:insert_before), "task_wrap.call_task", ["Nested.compute_nested_activity", task.method(:compute_nested_activity)]],
@@ -33,17 +33,24 @@ module Trailblazer
       end
 
       # For dynamic `Nested`s that do not expose an {Activity} interface.
-      # Since we do not know its outputs, we have to map them to :success and :failure, only.
       #
-      # This is what {Nested} in 2.0 used to do, where the outcome could only be true/false (or success/failure).
+      # Dynamic doesn't automatically connect outputs of runtime {Activity}
+      # at compile time (as we don't know which activity will be nested, obviously).
+      # So by default, it only connects good old success/failure ends. But it is also
+      # possible to connect all the ends of all possible dynamic activities
+      # by passing their list to {:auto_wire} option.
+      #
+      # step Nested(:compute_nested, auto_wire: [Create, Update])
       class Dynamic
-        def initialize(nested_activity_decider)
-          @nested_activity_decider = Option::KW(nested_activity_decider)
+        STATIC_OUTPUTS = {
+          :success => Activity::Output(Activity::Railway::End::Success.new(semantic: :success), :success),
+          :failure => Activity::Output(Activity::Railway::End::Failure.new(semantic: :failure), :failure),
+        }
 
-          @outputs         = {
-            :success => Activity::Output(Activity::Railway::End::Success.new(semantic: :success), :success),
-            :failure => Activity::Output(Activity::Railway::End::Failure.new(semantic: :failure), :failure)
-          }
+        def initialize(nested_activity_decider, auto_wire: [])
+          @nested_activity_decider  = Trailblazer::Option(nested_activity_decider)
+          @known_activities         = Array(auto_wire)
+          @outputs                  = compute_task_outputs
         end
 
         attr_reader :outputs
@@ -53,7 +60,7 @@ module Trailblazer
           (ctx, _), original_circuit_options = original_args
 
           # TODO: evaluate the option to get the actual "object" to call.
-          activity = @nested_activity_decider.(ctx, original_circuit_options)
+          activity = @nested_activity_decider.(ctx, keyword_arguments: ctx.to_hash, **original_circuit_options)
 
           # Overwrite :task so task_wrap.call_task will call this activity.
           # This is a trick so we don't have to repeat logic from #call_task here.
@@ -63,13 +70,28 @@ module Trailblazer
         end
 
         def compute_return_signal(wrap_ctx, original_args)
-          # Translate the genuine nested signal to the generic Dynamic end (success/failure, only).
-          # Note that here we lose information about what specific event was emitted.
-          wrap_ctx[:return_signal] = wrap_ctx[:return_signal].kind_of?(Activity::Railway::End::Success) ?
-            @outputs[:success].signal : @outputs[:failure].signal
+          # NOOP when @known_activities are present as all possible signals have been registered already.
+          if @known_activities.empty?
+            # Translate the genuine nested signal to the generic Dynamic end (success/failure, only).
+            # Note that here we lose information about what specific event was emitted.
+            wrap_ctx[:return_signal] = wrap_ctx[:return_signal].kind_of?(Activity::Railway::End::Success) ?
+              @outputs[:success].signal : @outputs[:failure].signal
+          end
 
           return wrap_ctx, original_args
         end
+
+        private def compute_task_outputs
+          # If :auto_wire is empty, we map outputs to :success and :failure only, for backward compatibility.
+          # This is what {Nested} in 2.0 used to do, where the outcome could only be true/false (or success/failure).
+          return STATIC_OUTPUTS if @known_activities.empty?
+
+          # Merge activity#outputs from all given auto_wirable activities to wire up for this dynamic task.
+          @known_activities.map do |activity|
+            # TODO: Replace this when it's helper gets added.
+            Hash[activity.to_h[:outputs].collect{ |output| [output.semantic, output] }]
+          end.inject(:merge)
+        end
       end
     end
   end

data/lib/trailblazer/macro/version.rb

@@ -1,7 +1,7 @@
 module Trailblazer
   module Version
     module Macro
-      VERSION = "2.1.1"
+      VERSION = "2.1.6"
     end
   end
 end

data/lib/trailblazer/macro/wrap.rb

@@ -48,7 +48,7 @@ module Trailblazer
 
         def call((ctx, flow_options), **circuit_options)
           block_calling_wrapped = -> {
-            call_wrapped_activity([ctx, flow_options], circuit_options)
+            call_wrapped_activity([ctx, flow_options], **circuit_options)
           }
 
           # call the user's Wrap {} block in the operation.

data/test/docs/guard_test.rb

@@ -113,8 +113,6 @@ end
 class DocsGuardInjectionTest < Minitest::Spec
   #:di-op
   class Create < Trailblazer::Operation
-    extend Trailblazer::Operation::Container
-
     step Policy::Guard( ->(options, current_user:, **) { current_user == Module } )
   end
   #:di-op end
@@ -124,9 +122,8 @@ class DocsGuardInjectionTest < Minitest::Spec
     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] >} }

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

@@ -22,6 +22,11 @@ class NestedInput < Minitest::Spec
     include T.def_steps(:validate)
   end
 
+  class JsonValidate < Validate
+    step :json
+    include T.def_steps(:json)
+  end
+
   it "Nested(Edit), without any options" do
       module A
 
@@ -79,11 +84,6 @@ class NestedInput < Minitest::Spec
         #~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()
 
   # edit/success
@@ -119,11 +119,6 @@ class NestedInput < Minitest::Spec
       end
       #:nested-dynamic end
 
-      class JsonValidate < Validate
-        step :json
-        include T.def_steps(:json)
-      end
-
     # `edit` and `update` can be called from Nested()
     end
 
@@ -131,29 +126,64 @@ class NestedInput < Minitest::Spec
     C::Create.(seq: [], params: nil).inspect(:seq).must_equal %{<Result:true [[:create, :validate, :json, :save]] >}
   end
 
-  let(:compute_edit) {
-    ->(ctx, what:, **) { what }
-  }
+  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
 
-  it "Nested(:method), :pass_fast => :fail_fast doesn't work with standard wiring" do
-    skip "we need to allow adding :outputs"
+    module D
 
-    compute_edit = self.compute_edit
+      create =
+      #:nested-with-pass-fast
+      class Create < Trailblazer::Operation
 
-    pass_fast = Class.new(Trailblazer::Operation) do
-      step :p, pass_fast: true
-      include T.def_steps(:p)
-    end
+        def compute_nested(ctx, **)
+          JustPassFast
+        end
 
-    create = Class.new(Trailblazer::Operation) do
-      step :a
-      step Nested(compute_edit, auto_wire: [pass_fast]), Output(:pass_fast) => Track(:fail_fast)
-      step :b
-      include T.def_steps(:a, :b)
+        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
+
+  it "Nested(:method, auto_wire: *activities) with :pass_fast => End()" do
+    module E
+      class JsonValidate < Trailblazer::Operation
+        step :validate, Output(:success) => End(:json_validate)
+        include T.def_steps(:validate)
+      end
+
+      #:nested-with-auto-wire
+      class Create < Trailblazer::Operation
+        step :create
+        step Nested(:compute_nested, auto_wire: [Validate, JsonValidate]),
+          Output(:json_validate) => End(:jsoned)
 
+        #~meths
+        def compute_nested(ctx, what:, **)
+          what
+        end
 
-    create.(seq: [], what: pass_fast).inspect(:seq).must_equal %{<Result:false [[:a, :c]] >}
+        include T.def_steps(:create)
+        #~meths end
+      end
+      #:nested-with-auto-wire end
+
+      result = Create.(seq: [], what: JsonValidate)
+
+      result.inspect(:seq).must_equal %{<Result:false [[:create, :validate]] >}
+      result.event.inspect.must_equal %{#<Trailblazer::Activity::End semantic=:jsoned>}
+    end
   end
 end
 

data/test/docs/rescue_test.rb

@@ -126,4 +126,29 @@ Rescue( handler: :instance_method )
     it { Memo::Create.( { seq: [], } ).inspect(:seq, :exception_class).must_equal %{<Result:true [[:find_model, :update, :rehash, :notify], nil] >} }
     it { Memo::Create.( { seq: [], rehash_raise: true } ).inspect(:seq, :exception_class).must_equal %{<Result:false [[:find_model, :update, :rehash, :log_error], RuntimeError] >} }
   end
+
+=begin
+Rescue(), fast_track: true {}
+=end
+  class RescueWithFastTrack < Minitest::Spec
+    Memo = Class.new
+
+    #:rescue-fasttrack
+    class Memo::Create < Trailblazer::Operation
+      rescue_block = ->(*) {
+        step :update, Output(:failure) => End(:fail_fast)
+        step :rehash
+      }
+
+      step :find_model
+      step Rescue(&rescue_block), fail_fast: true
+      step :notify
+      fail :log_error
+      #~methods
+      include T.def_steps(:find_model, :update, :notify, :log_error, :rehash)
+    end
+
+    it { Memo::Create.( { seq: [], } ).inspect(:seq).must_equal %{<Result:true [[:find_model, :update, :rehash, :notify]] >} }
+    it { Memo::Create.( { seq: [], update: false } ).inspect(:seq).must_equal %{<Result:false [[:find_model, :update]] >} }
+  end
 end

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,122 +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
-      #:wrap-only
-      step Wrap( MyTransaction ) {
+      step Wrap( HandleUnsafeProcess ) {
         step :update
         step :rehash
       }
-      #:wrap-only end
       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
 
@@ -278,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/operation/nested_test.rb

@@ -0,0 +1,65 @@
+require 'test_helper'
+
+class NestedTest < Minitest::Spec
+  DatabaseError = Class.new(Trailblazer::Activity::Signal)
+
+  class SignUp < Trailblazer::Operation
+    def self.b(ctx, **)
+      ctx[:seq] << :b
+      return DatabaseError
+    end
+
+    step method(:b), Output(DatabaseError, :db_error) => End(:db_error)
+  end
+
+  class SignIn < Trailblazer::Operation
+    include T.def_steps(:c)
+    step :c
+  end
+
+  it "allows connection with custom output of a nested activity" do
+    create = Class.new(Trailblazer::Operation) do
+      include T.def_steps(:a, :d)
+
+      step :a
+      step Nested(SignUp), Output(:db_error) => Track(:no_user)
+      step :d, magnetic_to: :no_user
+    end
+
+    result = create.(seq: [])
+    result.inspect(:seq).must_equal %{<Result:true [[:a, :b, :d]] >}
+    result.event.inspect.must_equal %{#<Trailblazer::Activity::Railway::End::Success semantic=:success>}
+  end
+
+  it "allows connecting dynamically nested activities with custom output when auto wired" do
+    create = Class.new(Trailblazer::Operation) do
+      def compute_nested(ctx, what:, **)
+        what
+      end
+
+      include T.def_steps(:a, :d)
+
+      step :a
+      step Nested(:compute_nested, auto_wire: [SignUp, SignIn]), Output(:db_error) => Track(:no_user)
+      step :d, magnetic_to: :no_user
+    end
+
+    result = create.(seq: [], what: SignUp)
+    result.inspect(:seq).must_equal %{<Result:true [[:a, :b, :d]] >}
+    result.event.inspect.must_equal %{#<Trailblazer::Activity::Railway::End::Success semantic=:success>}
+  end
+
+  it "raises RuntimeError if dynamically nested activities with custom output are not auto wired" do
+    exception = assert_raises RuntimeError do
+      Class.new(Trailblazer::Operation) do
+        def compute_nested(ctx, what:, **)
+          what
+        end
+
+        step Nested(:compute_nested), Output(:db_error) => Track(:no_user)
+      end
+    end
+
+    exception.inspect.must_match 'No `db_error` output found'
+  end
+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

@@ -25,7 +25,8 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "roar"
   spec.add_development_dependency "trailblazer-developer"
 
-  spec.add_dependency "trailblazer-operation", ">= 0.6.0" # TODO: this dependency will be removed.
+  spec.add_dependency "trailblazer-activity-dsl-linear", ">= 0.4.0", "< 0.5.0"
+  spec.add_dependency "trailblazer-operation", ">= 0.7.0" # TODO: this dependency will be removed.
 
   spec.required_ruby_version = ">= 2.2.0"
 end

metadata

@@ -1,15 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: trailblazer-macro
 version: !ruby/object:Gem::Version
-  version: 2.1.1
+  version: 2.1.6
 platform: ruby
 authors:
 - Nick Sutterer
 - Marc Tich
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2019-12-19 00:00:00.000000000 Z
+date: 2021-03-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -95,20 +95,40 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: trailblazer-activity-dsl-linear
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.4.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 0.5.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.4.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 0.5.0
 - !ruby/object:Gem::Dependency
   name: trailblazer-operation
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.6.0
+        version: 0.7.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.6.0
+        version: 0.7.0
 description: Macros for Trailblazer's operation
 email:
 - apotonick@gmail.com
@@ -117,10 +137,10 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".github/workflows/ci.yml"
 - ".gitignore"
 - ".rubocop.yml"
 - ".rubocop_todo.yml"
-- ".travis.yml"
 - CHANGES.md
 - Gemfile
 - LICENSE
@@ -145,6 +165,7 @@ files:
 - test/docs/wrap_test.rb
 - test/operation/integration_test.rb
 - test/operation/model_test.rb
+- test/operation/nested_test.rb
 - test/operation/pundit_test.rb
 - test/test_helper.rb
 - trailblazer-macro.gemspec
@@ -152,7 +173,7 @@ homepage: http://trailblazer.to
 licenses:
 - LGPL-3.0
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -167,8 +188,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
-signing_key: 
+rubygems_version: 3.2.3
+signing_key:
 specification_version: 4
 summary: 'Macros for Trailblazer''s operation: Policy, Wrap, Rescue and more.'
 test_files:
@@ -181,5 +202,6 @@ test_files:
 - test/docs/wrap_test.rb
 - test/operation/integration_test.rb
 - test/operation/model_test.rb
+- test/operation/nested_test.rb
 - test/operation/pundit_test.rb
 - test/test_helper.rb

data/.travis.yml

@@ -1,9 +0,0 @@
-language: ruby
-rvm:
-  - 2.6.5
-  - 2.5.5
-  - 2.4.4
-  - 2.3.7
-  - 2.2
-
-cache: bundler