trailblazer-macro 2.1.6 → 2.1.10.beta1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d789d88096949c41a15147feed363efab5c86e586b4f76c819e12f6e8f2d4a70
-  data.tar.gz: fbe7775b4330bc7b607058da66c896fe461e73b1337e747c23eb87acb04b8d30
+  metadata.gz: 4e07fee7d3fb35d6b830f020d3d3881be004a64ca3d6a82a9dce8ed314d732f5
+  data.tar.gz: e8a2f00963f34d5ac031e80df423700148110afd1f3ae7132837992de8542e5b
 SHA512:
-  metadata.gz: df7f0de0c1107ea8c9b3803e8343907c0deb78e943ac2298a114db9fedb6de88252f5055a247b516fa3c80a2432f52913fd6d84ceb189779b58c87da6204a20f
-  data.tar.gz: a1e7a11851d02b26badfbff8aa6932810bc2e32ae3d1f4ce5fd73f2bf26284bff62a88b1fd27d29f5b82a7962e61fd0655b97f483483ff6df5cffdb3326f51e0
+  metadata.gz: 2d304e5385fa03e95a51db017f7d53bb7afb6d9e6e52f90869f01642d3c40848c9cd4abc327daf5a7bfb8ede5d3266f6a73c704fd742fe55e7ee7a37f7634571
+  data.tar.gz: 971ffebfbcd3ef1ba280bc53efef3983ea489568aafa85e4e53089dda7401c2cfd988aea0d0f6cc425a523ecd8a1372ae4b502f21d15d20f49345ffd486ab6c4

data/.github/workflows/ci.yml

@@ -6,7 +6,7 @@ jobs:
       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]
+        ruby: [2.5, 2.6, 2.7, '3.0', "3.1", head, jruby]
     runs-on: ubuntu-latest
     steps:
     - uses: actions/checkout@v2

data/CHANGES.md

@@ -1,3 +1,23 @@
+# 2.1.10
+
+* In `Nested()`, we no longer use `Railway::End::Success` and `Railway::End::Failure` as static outputs but
+  simply use `Railway`'s default termini objects.
+* Use `dsl`'s new `Inject()` API instead of a overriding `:inject` in `Model()` and `Policy()`.
+
+# 2.1.9
+
+* Allow omitting `:params` when calling the operation by defaulting it to `{}` in `Model()`.
+* Use `dsl-linear` 0.5.0 and above, which allows removing `Inject()` uses.
+
+# 2.1.8
+
+Yanked due to inconsistency.
+
+# 2.1.7
+
+* Improve `Nested()` warning message.
+* Fix exception in `Rescue()` macro when it's handler is a `Module`.
+
 # 2.1.6
 
 * Allow connecting ends of the dynamically selected activity for `Nested()` using `:auto_wire`.

data/README.md

@@ -2,7 +2,7 @@
 All common Macro's for Trailblazer::Operation, will come here
 
 ## TODO
-Describe the following Macro's:
+Describe the following Macros:
 - Nested
 - Rescue
 - Wrap

data/lib/trailblazer/macro/guard.rb

@@ -8,7 +8,6 @@ module Trailblazer::Macro
       def self.build(callable)
         option = Trailblazer::Option(callable)
 
-        # this gets wrapped in a Operation::Result object.
         ->((ctx, *), **circuit_args) do
           Trailblazer::Operation::Result.new(!!option.call(ctx, keyword_arguments: ctx.to_hash, **circuit_args), {})
         end

data/lib/trailblazer/macro/model.rb

@@ -1,54 +1,60 @@
-module Trailblazer::Macro
+module Trailblazer
+  module Macro
 
-  Linear = Trailblazer::Activity::DSL::Linear
+    def self.Model(model_class = nil, action = :new, find_by_key = :id, id: 'model.build', not_found_terminus: false)
+      task = Activity::TaskBuilder::Binary(Model.new)
 
-  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)
+      injections = {
+        Activity::Railway.Inject() => [:params], # pass-through {:params} if it's in ctx.
 
-    injection = Trailblazer::Activity::TaskWrap::Inject::Defaults::Extension(
-      :"model.class"          => model_class,
-      :"model.action"         => action,
-      :"model.find_by_key"    => find_by_key
-    )
+        # defaulting as per Inject() API.
+        Activity::Railway.Inject() => {
+          :"model.class"          => ->(*) { model_class },
+          :"model.action"         => ->(*) { action },
+          :"model.find_by_key"    => ->(*) { find_by_key },
+        }
+      }
 
-    options = { task: task, id: id, extensions: [injection] }
-    options = options.merge(Linear::Output(:failure) => Linear::End(:not_found)) if not_found_terminus
+      options = {task: task, id: id}.merge(injections)
 
-    options
-  end
+      options = options.merge(Activity::Railway.Output(:failure) => Activity::Railway.End(:not_found)) if not_found_terminus
 
-  class Model
-    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?, {})
-
-      result.success?
+      options
     end
 
-    class Builder
-      def call(options, params)
-        action        = options[:"model.action"] || :new
-        model_class   = options[:"model.class"]
-        find_by_key   = options[:"model.find_by_key"] || :id
-        action        = :pass_through unless %i[new find_by].include?(action)
-
-        send("#{action}!", model_class, params, options[:"model.action"], find_by_key)
-      end
-
-      def new!(model_class, params, *)
-        model_class.new
-      end
+    class Model
+      def call(ctx, params: {}, **)
+        builder                 = Model::Builder.new
+        ctx[:model]         = model = builder.call(ctx, params)
+        ctx[:"result.model"] = result = Operation::Result.new(!model.nil?, {})
 
-      # Doesn't throw an exception and will return false to divert to Left.
-      def find_by!(model_class, params, action, find_by_key, *)
-        model_class.find_by(find_by_key.to_sym => params[find_by_key])
+        result.success?
       end
 
-      # Call any method on the model class and pass find_by_key, for example find(params[:id]).
-      def pass_through!(model_class, params, action, find_by_key, *)
-        model_class.send(action, params[find_by_key])
+      class Builder
+        def call(ctx, params)
+          action        = ctx[:"model.action"]
+          model_class   = ctx[:"model.class"]
+          find_by_key   = ctx[:"model.find_by_key"]
+          action        = :pass_through unless %i[new find_by].include?(action)
+
+          send("#{action}!", model_class, params, ctx[:"model.action"], find_by_key)
+        end
+
+        def new!(model_class, params, *)
+          model_class.new
+        end
+
+        # Doesn't throw an exception and will return false to divert to Left.
+        def find_by!(model_class, params, action, find_by_key, *)
+          model_class.find_by(find_by_key.to_sym => params[find_by_key])
+        end
+
+        # Call any method on the model class and pass find_by_key, for example find(params[:id]).
+        def pass_through!(model_class, params, action, find_by_key, *)
+          model_class.send(action, params[find_by_key])
+        end
       end
     end
-  end
+  end # Macro
 end

data/lib/trailblazer/macro/nested.rb

@@ -4,25 +4,31 @@ module Trailblazer
     # {Nested} macro.
     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)
+        caller_location = caller_locations(2, 1)[0]
+        warn "[Trailblazer]#{caller_location.absolute_path}: " \
+             "Using the `Nested()` macro with operations and activities is deprecated. " \
+             "Replace `Nested(#{callable})` with `Subprocess(#{callable})`."
+
+        return Activity::Railway.Subprocess(callable)
       end
 
-      # dynamic
-      task = Nested::Dynamic.new(callable, auto_wire: auto_wire)
+      task, outputs, compute_legacy_return_signal = Nested.Dynamic(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)]],
-        [Activity::TaskWrap::Pipeline.method(:insert_after),  "task_wrap.call_task", ["Nested.compute_return_signal", task.method(:compute_return_signal)]],
+        [task, id: "Nested.compute_nested_activity", prepend: "task_wrap.call_task"],
       ]
 
-      task_wrap_extension = Activity::TaskWrap::Extension(merge: merge)
+      if compute_legacy_return_signal
+        merge << [compute_legacy_return_signal, id: "Nested.compute_return_signal", append: "task_wrap.call_task"]
+      end
+
+      task_wrap_extension = Activity::TaskWrap::Extension::WrapStatic.new(extension: Activity::TaskWrap::Extension(*merge))
 
       {
         task:       task,
         id:         id,
         extensions: [task_wrap_extension],
-        outputs:    task.outputs,
+        outputs:    outputs,
       }
     end
 
@@ -41,57 +47,64 @@ module Trailblazer
       # by passing their list to {:auto_wire} option.
       #
       # step Nested(:compute_nested, auto_wire: [Create, Update])
-      class Dynamic
-        STATIC_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
+      def self.Dynamic(nested_activity_decider, auto_wire:)
+        if auto_wire.empty?
+          is_legacy = true # no auto_wire means we need to compute the legacy return signal.
+          auto_wire = [Class.new(Activity::Railway)]
         end
 
-        attr_reader :outputs
+        outputs = outputs_for(auto_wire)
+        task    = Dynamic.new(nested_activity_decider)
+        compute_legacy_return_signal = Dynamic::ComputeLegacyReturnSignal.new(outputs) if is_legacy
+
+        return task, outputs, compute_legacy_return_signal
+      end
+
+      # Go through the list of all possible nested activities and compile the total sum of possible outputs.
+      # FIXME: WHAT IF WE HAVE TWO IDENTICALLY NAMED OUTPUTS?
+      # @private
+      def self.outputs_for(activities)
+        activities.map do |activity|
+          Activity::Railway.Subprocess(activity)[:outputs]
+        end.inject(:merge)
+      end
+
+      class Dynamic
+        def initialize(nested_activity_decider)
+          @nested_activity_decider = Trailblazer::Option(nested_activity_decider)
+        end
 
         # TaskWrap step.
-        def compute_nested_activity(wrap_ctx, original_args)
+        def call(wrap_ctx, original_args)
           (ctx, _), original_circuit_options = original_args
 
           # TODO: evaluate the option to get the actual "object" to call.
           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.
+          # This is a taskWrap trick so we don't have to repeat logic from #call_task here.
           wrap_ctx[:task] = activity
 
           return wrap_ctx, original_args
         end
 
-        def compute_return_signal(wrap_ctx, original_args)
-          # 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
+        # TODO: remove me when we make {:auto_wire} mandatory.
+        class ComputeLegacyReturnSignal
+          SUCCESS_SEMANTICS = [:success, :pass_fast] # TODO: make this injectable/or get it from operation.
+
+          def initialize(outputs)
+            @outputs = outputs # not needed for auto_wire!
           end
 
-          return wrap_ctx, original_args
-        end
+          def call(wrap_ctx, original_args)
+            actual_semantic  = wrap_ctx[:return_signal].to_h[:semantic]
+            applied_semantic = SUCCESS_SEMANTICS.include?(actual_semantic) ? :success : :failure
 
-        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?
+            wrap_ctx[:return_signal] = @outputs.fetch(applied_semantic).signal
 
-          # 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
+            return wrap_ctx, original_args
+          end
+        end # ComputeLegacyReturnSignal
       end
     end
   end

data/lib/trailblazer/macro/policy.rb

@@ -8,35 +8,38 @@ module Trailblazer::Macro
         @path = path
       end
 
-      # incoming low-level {Task API}.
+      # incoming low-level {circuit interface}.
       # outgoing Task::Binary API.
-      def call((options, flow_options), **circuit_options)
-        condition = options[@path] # this allows dependency injection.
-        result    = condition.([options, flow_options], **circuit_options)
+      #
+      # Retrieve the injectable {condition}, execute it and interpret its {Result} object.
+      def call((ctx, flow_options), **circuit_options)
+        condition = ctx[@path] # this allows dependency injection.
+        result    = condition.([ctx, flow_options], **circuit_options)
 
-        options[:"policy.#{@name}"]        = result[:policy] # assign the policy as a skill.
-        options[:"result.policy.#{@name}"] = result
+        ctx[:"policy.#{@name}"]        = result[:policy] # assign the policy as a ctx variable.
+        ctx[:"result.policy.#{@name}"] = result
 
         # flow control
-        signal = result.success? ? Trailblazer::Activity::Right : Trailblazer::Activity::Left # since we & this, it's only executed OnRight and the return boolean decides the direction, input is passed straight through.
+        signal = result.success? ? Trailblazer::Activity::Right : Trailblazer::Activity::Left
 
-        return signal, [options, flow_options]
+        return signal, [ctx, flow_options]
       end
     end
 
-    # Adds the `yield` result to the pipe and treats it like a
+    # Adds the `yield` result to the Railway and treats it like a
     # policy-compatible  object at runtime.
-    def self.step(condition, options, &block)
-      name = options[:name]
+    def self.step(condition, name: nil, &block)
       path = :"policy.#{name}.eval"
-
       task = Eval.new(name: name, path: path)
 
-      injection = Trailblazer::Activity::TaskWrap::Inject::Defaults::Extension(
-        path => condition
-      )
+      injections = {
+        Trailblazer::Activity::Railway.Inject() => {
+          # :"policy.default.eval"
+          path => ->(*) { condition }
+        }
+      }
 
-      {task: task, id: path, extensions: [injection]}
+      {task: task, id: path}.merge(injections)
     end
   end
 end

data/lib/trailblazer/macro/rescue.rb

@@ -28,11 +28,8 @@ module Trailblazer
     # TODO: remove me in 2.2.
     module Rescue
       def self.deprecate_positional_handler_signature(handler)
-        return handler if handler.is_a?(Symbol) # can't do nutting about this.
-
-        arity = handler.is_a?(Class) ? handler.method(:call).arity : handler.arity
-
-        return handler if arity != 2 # means (exception, (ctx, flow_options), *, &block), "new style"
+        return handler if handler.is_a?(Symbol) # can't do nothing about this.
+        return handler if handler.method(:call).arity != 2 # means (exception, (ctx, flow_options), *, &block), "new style"
 
         ->(exception, (ctx, flow_options), **circuit_options, &block) do
           warn "[Trailblazer] Rescue handlers have a new signature: (exception, *, &block)"

data/lib/trailblazer/macro/version.rb

@@ -1,7 +1,7 @@
 module Trailblazer
   module Version
     module Macro
-      VERSION = "2.1.6"
+      VERSION = "2.1.10.beta1"
     end
   end
 end

data/lib/trailblazer/macro.rb

@@ -1,5 +1,4 @@
 require "forwardable"
-require "trailblazer/activity"
 require "trailblazer/activity/dsl/linear"
 require "trailblazer/operation" # TODO: remove this dependency
 
@@ -17,12 +16,13 @@ module Trailblazer
 
   # 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
+    Constants::Policy = Trailblazer::Macro::Policy
 
-    module ClassMethods
-      extend Forwardable
-      def_delegators Trailblazer::Macro, :Model, :Nested, :Wrap, :Rescue
-    end # ClassMethods
+    # Extending the {Linear::Helper} namespace is the canonical way to import
+    # macros into Railway, FastTrack, Operation, etc.
+    extend Forwardable
+    def_delegators Trailblazer::Macro, :Model, :Nested, :Wrap, :Rescue
   end # Helper
 end

data/test/docs/model_test.rb

@@ -16,11 +16,22 @@ class DocsModelTest < Minitest::Spec
 
   #:op
   class Create < Trailblazer::Operation
-    step Model( Song, :new )
+    step Model(Song, :new)
     # ..
   end
   #:op end
 
+
+  it "defaults {:params} to empty hash when not passed" do
+    result = Create.({})
+    assert_equal true, result.success?
+    assert_equal %{#<struct DocsModelTest::Song id=nil, title=nil>}, result[:model].inspect
+
+    result = Update.({})
+    assert_equal false, result.success?
+    assert_equal "nil", result[:model].inspect
+  end
+
   it do
     #:create
     result = Create.(params: {})
@@ -121,4 +132,43 @@ class DocsModelTest < Minitest::Spec
     result.success?.must_equal true
     result[:model].inspect.must_equal %{#<struct DocsModelTest::Song id=100, title=nil>}
   end
+
+  it "allows injecting {:model.class} and friends" do
+    class Hit < Song
+    end
+
+    #:di-model-class
+    result = Create.(params: {}, :"model.class" => Hit)
+    #:di-model-class end
+
+    result[:model].inspect.must_equal %{#<struct DocsModelTest::Hit id=nil, title=nil>}
+
+  # inject all variables
+    #:di-all
+    result = Create.(
+      params:               {title: "Olympia"}, # some random variable.
+      "model.class":        Hit,
+      "model.action":       :find_by,
+      "model.find_by_key": :title
+    )
+    #:di-all end
+
+    result[:model].inspect.must_equal %{#<struct DocsModelTest::Hit id=2, title="Olympia">}
+
+  # use empty Model() and inject {model.class} and {model.action}
+    module A
+      #:op-model-empty
+      class Create < Trailblazer::Operation
+        step Model()
+        # ..
+      end
+      #:op-model-empty end
+    end # A
+
+    result = A::Create.(params: {}, :"model.class" => Hit)
+
+    result[:model].inspect.must_equal %{#<struct DocsModelTest::Hit id=nil, title=nil>}
+
+
+  end
 end

data/test/docs/nested_test.rb

@@ -151,7 +151,8 @@ class NestedInput < Minitest::Spec
       end
       #:nested-with-pass-fast end
 
-      # pass fast
+      #= {#save} is still called because the {End.pass_fast} terminus is automatically wired to
+      #= the success "output" of Nested().
       create.(seq: []).inspect(:seq).must_equal %{<Result:true [[:create, :just_pass_fast, :save]] >}
     end
   end
@@ -159,15 +160,16 @@ class NestedInput < Minitest::Spec
   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)
+        step :validate, Output(:failure) => End(:invalid_json)
+        step :save
+        include T.def_steps(:validate, :save)
       end
 
       #:nested-with-auto-wire
       class Create < Trailblazer::Operation
         step :create
         step Nested(:compute_nested, auto_wire: [Validate, JsonValidate]),
-          Output(:json_validate) => End(:jsoned)
+          Output(:invalid_json) => End(:jsoned)
 
         #~meths
         def compute_nested(ctx, what:, **)
@@ -179,10 +181,36 @@ class NestedInput < Minitest::Spec
       end
       #:nested-with-auto-wire end
 
-      result = Create.(seq: [], what: JsonValidate)
+
+    #@ nested {JsonValidate} ends on {End.success}
+      result = Create.(seq: [], what: JsonValidate, validate: true)
+
+      result.inspect(:seq).must_equal %{<Result:true [[:create, :validate, :save]] >}
+      result.event.inspect.must_equal %{#<Trailblazer::Activity::Railway::End::Success semantic=:success>}
+
+    #@ nested {JsonValidate} ends on {End.invalid_json} because validate fails.
+      result = Create.(seq: [], what: JsonValidate, validate: false)
 
       result.inspect(:seq).must_equal %{<Result:false [[:create, :validate]] >}
       result.event.inspect.must_equal %{#<Trailblazer::Activity::End semantic=:jsoned>}
+
+    #@ nested {JsonValidate} ends on {End.failure} because save fails.
+      result = Create.(seq: [], what: JsonValidate, save: false)
+
+      result.inspect(:seq).must_equal %{<Result:false [[:create, :validate, :save]] >}
+      result.event.inspect.must_equal %{#<Trailblazer::Activity::Railway::End::Failure semantic=:failure>}
+
+    #@ nested {Validate} ends on {End.failure} because validate fails.
+      result = Create.(seq: [], what: Validate, validate: false)
+
+      result.inspect(:seq).must_equal %{<Result:false [[:create, :validate]] >}
+      result.event.inspect.must_equal %{#<Trailblazer::Activity::Railway::End::Failure semantic=:failure>}
+
+    #@ nested {Validate} ends on {End.success}.
+      result = Create.(seq: [], what: Validate)
+
+      result.inspect(:seq).must_equal %{<Result:true [[:create, :validate]] >}
+      result.event.inspect.must_equal %{#<Trailblazer::Activity::Railway::End::Success semantic=:success>}
     end
   end
 end

data/test/docs/rescue_test.rb

@@ -66,7 +66,7 @@ plain Rescue()
 =begin
 Rescue( handler: X )
 =end
-  class RescueWithHandlerTest < Minitest::Spec
+  class RescueWithClassHandlerTest < Minitest::Spec
     Memo = Class.new
 
     #:rescue-handler
@@ -97,10 +97,35 @@ Rescue( handler: X )
     it { Memo::Create.( { seq: [], rehash_raise: true } ).inspect(:seq, :exception_class).must_equal %{<Result:false [[:find_model, :update, :rehash, :log_error], RuntimeError] >} }
   end
 
+  class RescueWithModuleHandlerTest < Minitest::Spec
+    Memo = Class.new
+
+    module MyHandler
+      def self.call(exception, (ctx), *)
+        ctx[:exception_class] = exception.class
+      end
+    end
+
+    class Memo::Create < Trailblazer::Operation
+      step :find_model
+      step Rescue( RuntimeError, handler: MyHandler ) {
+        step :update
+        step :rehash
+      }
+      step :notify
+      fail :log_error
+      include T.def_steps(:find_model, :update, :notify, :log_error)
+      include Rehash
+    end
+
+    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( handler: :instance_method )
 =end
-  class RescueWithHandlerTest < Minitest::Spec
+  class RescueWithMethodHandlerTest < Minitest::Spec
     Memo = Class.new
 
     #:rescue-method

data/test/operation/nested_test.rb

@@ -49,6 +49,28 @@ class NestedTest < Minitest::Spec
     result.event.inspect.must_equal %{#<Trailblazer::Activity::Railway::End::Success semantic=:success>}
   end
 
+  #@ unit test
+  # TODO: make me a non-Operation test.
+  it "allows using multiple Nested() per operation" do
+    create = Class.new(Trailblazer::Operation) do
+      def compute_nested(ctx, what:, **)
+        what
+      end
+
+      step Nested(:compute_nested)
+      step Nested(:compute_nested), id: :compute_nested_again
+    end
+
+    #@ we want both Nested executed
+    result = create.(seq: [], what: SignIn)
+    result.inspect(:seq).must_equal %{<Result:true [[:c, :c]] >}
+    result.event.inspect.must_equal %{#<Trailblazer::Activity::Railway::End::Success semantic=:success>}
+
+    result = create.wtf?(seq: [], what: SignUp)
+    result.inspect(:seq).must_equal %{<Result:false [[:b]] >}
+    result.event.inspect.must_equal %{#<Trailblazer::Activity::Railway::End::Failure semantic=:failure>}
+  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
@@ -62,4 +84,15 @@ class NestedTest < Minitest::Spec
 
     exception.inspect.must_match 'No `db_error` output found'
   end
+
+  it "shows warning if `Nested()` is being used instead of `Subprocess()` for static activities" do
+    _, warnings = capture_io do
+      Class.new(Trailblazer::Operation) do
+        step Nested(SignUp)
+      end
+    end
+
+    warnings.must_equal %Q{[Trailblazer]#{__FILE__}: Using the `Nested()` macro with operations and activities is deprecated. Replace `Nested(NestedTest::SignUp)` with `Subprocess(NestedTest::SignUp)`.
+}
+  end
 end

data/trailblazer-macro.gemspec

@@ -25,8 +25,8 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "roar"
   spec.add_development_dependency "trailblazer-developer"
 
-  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.add_dependency "trailblazer-activity-dsl-linear", ">= 1.0.0.beta1", "< 1.1.0"
+  spec.add_dependency "trailblazer-operation", ">= 0.8.0.beta1" # TODO: this dependency will be removed. currently needed for tests?!
 
   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.6
+  version: 2.1.10.beta1
 platform: ruby
 authors:
 - Nick Sutterer
 - Marc Tich
-autorequire:
+autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-03-11 00:00:00.000000000 Z
+date: 2022-07-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -101,34 +101,34 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.4.0
+        version: 1.0.0.beta1
     - - "<"
       - !ruby/object:Gem::Version
-        version: 0.5.0
+        version: 1.1.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.4.0
+        version: 1.0.0.beta1
     - - "<"
       - !ruby/object:Gem::Version
-        version: 0.5.0
+        version: 1.1.0
 - !ruby/object:Gem::Dependency
   name: trailblazer-operation
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.7.0
+        version: 0.8.0.beta1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.7.0
+        version: 0.8.0.beta1
 description: Macros for Trailblazer's operation
 email:
 - apotonick@gmail.com
@@ -173,7 +173,7 @@ homepage: http://trailblazer.to
 licenses:
 - LGPL-3.0
 metadata: {}
-post_install_message:
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -184,12 +184,12 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: 2.2.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubygems_version: 3.2.3
-signing_key:
+signing_key: 
 specification_version: 4
 summary: 'Macros for Trailblazer''s operation: Policy, Wrap, Rescue and more.'
 test_files: