trailblazer-macro 2.1.14 → 2.1.15

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bdbc731c17b52586de5a713605423d506a6ea91866db65f4a04be858fa5afb1e
-  data.tar.gz: 254f4e89aca81b120e6f1392c99ac30dfe9dd70cde79e2f2a9aa669a88448bfb
+  metadata.gz: 173e4338e28a9317e1d4982e9cfa9c2662b1639f852c63e17d389d8aac1dbf6f
+  data.tar.gz: cfe156150849b2114783ae54799dbc6a9cc1aaf98ee94a076cf2236855c1aebd
 SHA512:
-  metadata.gz: d0b26e20fe1f14def81e30ca0a39a37cf58b6257530307bb9db1f80d914c04b8c5dfb4143f98c012a0605074f31c1cf42b91930aeaecd1cf8f820158cfac6ee4
-  data.tar.gz: cdee315a8ac8900bf438694f7320b88cd3ceb32436baf544826bb550289f56a466ef18da3142ef15e1bde8eb3fc575eadb87e6670106c6be204e921d1285ab00
+  metadata.gz: b5d91f20bf7ea34b3328a7cb2419dc3d3df264e998605f887afee09379bc10a41222016f0f63c0512f5caab2236b8528997096baf3b4ec0f17ae2b4b8bb25303
+  data.tar.gz: 3a80eb7b70c7c8d9667bad7571c7d8471dc7bfc28ad00fdb40f94ceb5dc4fcae1de7ffae9a4d76848c61526f06cb2d0d85c612e2a5d01f2acb849ed28c1821f0

data/CHANGES.md

@@ -1,3 +1,9 @@
+# 2.1.15
+
+* Use `Macro.id_for` for `Rescue`, meaning IDs will now be consistent à la `Rescue/1` instead of `Rescue(1)`.
+* In `Each`'s tracing code, use `developer-0.1.0` API.
+* Use `trailblazer-operation-0.10.1`.
+
 # 2.1.14
 
 * Use `trailblazer-activity-dsl-linear-1.2.0` and change internal API as required.

data/Gemfile

@@ -4,6 +4,7 @@ source 'https://rubygems.org'
 gemspec
 
 # gem "trailblazer-developer", github: "trailblazer/trailblazer-developer"
+# gem "trailblazer-developer", path: "../trailblazer-developer"
 # gem "trailblazer-activity", github: "trailblazer/trailblazer-activity"
 # gem "trailblazer-activity-dsl-linear", github: "trailblazer/trailblazer-activity-dsl-linear"
 # gem "trailblazer-macro-contract", git: "https://github.com/trailblazer/trailblazer-macro-contract"
@@ -11,7 +12,7 @@ gemspec
 # gem "trailblazer-activity-dsl-linear",  path: "../trailblazer-activity-dsl-linear"
 # gem "trailblazer-developer",            path: "../trailblazer-developer"
 # gem "trailblazer-activity",             path: "../trailblazer-activity"
-# gem "trailblazer-operation",            path: "../trailblazer-operation"
+gem "trailblazer-operation",            path: "../trailblazer-operation"
 
 gem "minitest-line"
 # gem "trailblazer-core-utils", path: "../trailblazer-core-utils"

data/lib/trailblazer/macro/each.rb

@@ -66,11 +66,16 @@ module Trailblazer
       ITERATION_INPUT_PIPE  = Activity::DSL::Linear::VariableMapping::DSL.pipe_for_composable_input()
 
       # Gets included in Debugger's Normalizer. Results in IDs like {invoke_block_activity.1}.
-      def self.compute_runtime_id(ctx, captured_node:, activity:, compile_id:, **)
+      def self.compute_runtime_id(ctx, trace_node:, activity:, compile_id:, **)
         # activity is the host activity
         return compile_id unless activity.to_h[:config][:each] == true
 
-        index = captured_node.captured_input.data[:ctx_snapshot].fetch(:index)
+        # Developer::Trace::Snapshot::Ctx.ctx_snapshot_for(trace_node.snapshot_before, .data
+# FIXME: BETTER API, we need access to stack now
+
+
+        # index = trace_node.snapshot_before.data[:ctx_snapshot].fetch(:index)
+        index = trace_node.snapshot_before.data[:ctx_variable_changeset].find { |name, version, value| name == :index }[2]
 
         ctx[:runtime_id] = "#{compile_id}.#{index}"
       end

data/lib/trailblazer/macro/rescue.rb

@@ -1,10 +1,8 @@
-require "securerandom"
-
 module Trailblazer
   module Macro
     NoopHandler = lambda { |*| }
 
-    def self.Rescue(*exceptions, handler: NoopHandler, &block)
+    def self.Rescue(*exceptions, handler: NoopHandler, id: Rescue.random_id, &block)
       exceptions = [StandardError] unless exceptions.any?
 
       handler    = Rescue.deprecate_positional_handler_signature(handler)
@@ -22,9 +20,7 @@ module Trailblazer
         end
       end
 
-      Wrap(rescue_block, id: "Rescue(#{SecureRandom.hex(4)})", &block)
-      # FIXME: name
-      # [ step, name: "Rescue:#{block.source_location.last}" ]
+      Wrap(rescue_block, id: id, &block)
     end
 
     # TODO: remove me in 2.2.
@@ -38,6 +34,12 @@ module Trailblazer
           handler.(exception, ctx, &block)
         end
       end
+
+      # TODO: for legacy reasons, we pass `:id` to {#id_for}. In 2.2, remove the id hint and use
+      # generic {Macro.id_for} behavior.
+      def self.random_id
+        Macro.id_for(nil, macro: :Rescue, id: rand(100))
+      end
     end
   end
 end

data/lib/trailblazer/macro/version.rb

@@ -1,7 +1,7 @@
 module Trailblazer
   module Version
     module Macro
-      VERSION = "2.1.14"
+      VERSION = "2.1.15"
     end
   end
 end

data/lib/trailblazer/macro.rb

@@ -51,8 +51,14 @@ module Trailblazer
       return block_activity, block_activity.to_h[:outputs]
     end
 
-    def self.id_for(user_proc, macro:, hint: nil)
-      id =
+    module IdFor
+      module_function
+
+      def call(user_proc, macro:, hint: nil, id: from_callable(user_proc, hint: hint))
+        [macro, id].join("/")
+      end
+
+      def from_callable(user_proc, hint: nil)
         if user_proc.is_a?(Class)
           user_proc.to_s
         elsif user_proc.instance_of?(Method)
@@ -60,8 +66,11 @@ module Trailblazer
         else
           hint || rand(4)
         end
+      end
+    end
 
-      "#{macro}/#{id}"
+    def self.id_for(user_proc, **options)
+      IdFor.(user_proc, **options)
     end
   end # Macro
 

data/test/docs/each_test.rb

@@ -740,8 +740,11 @@ class DocsEachUnitTest < Minitest::Spec
 
     stack, signal, (ctx, _) = Trailblazer::Developer::Trace.invoke(activity, [ctx, {}])
 
-    assert_equal Trailblazer::Developer::Trace::Present.(stack,
-      node_options: {stack.to_a[0] => {label: "<a-Each-b>"}}), %{<a-Each-b>
+    output = Trailblazer::Developer::Trace::Present.(stack) do |trace_nodes:, **|
+      {node_options: {trace_nodes[0] => {label: "<a-Each-b>"}}}
+    end
+
+    assert_equal output, %{<a-Each-b>
 |-- Start.default
 |-- a
 |-- Each/1

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\(.{8}\),>nested/ } # FIXME: better introspect tests for all id-generating macros.
+  it { Trailblazer::Developer.railway(NestedInsanity).must_match /\[>Rescue\/.{1,3},>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] >} }
@@ -43,31 +43,37 @@ class RescueTest < Minitest::Spec
 plain Rescue()
 =end
   class RescueWithoutHandlerTest < Minitest::Spec
-    Memo = Class.new
+    Song = Class.new
+    module Song::Activity; end
 
-    class Memo::Create < Trailblazer::Operation
-      step :find_model
+    #:no-args
+    class Song::Activity::Create < Trailblazer::Activity::Railway
+      step :create_model
       step Rescue() {
-        step :update
+        step :upload
         step :rehash
       }
       step :notify
       fail :log_error
       #~methods
-      include T.def_steps(:find_model, :update, :notify, :log_error)
+      include T.def_steps(:create_model, :upload, :notify, :log_error)
       include Rehash
       #~methods end
     end
+    #:no-args 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).must_equal %{<Result:false [[:find_model, :update, :rehash, :log_error]] >} }
+    it { assert_invoke Song::Activity::Create, seq: "[:create_model, :upload, :rehash, :notify]" }
+    it { assert_invoke Song::Activity::Create, rehash_raise: RuntimeError, terminus: :failure, seq: "[:create_model, :upload, :rehash, :log_error]", exception_class: RuntimeError }
+    it { assert_invoke Song::Activity::Create, rehash_raise: :bla, terminus: :failure, seq: "[:create_model, :upload, :rehash, :log_error]", exception_class: :bla }
+    it { assert_invoke Song::Activity::Create, rehash_raise: NoMethodError, terminus: :failure, seq: "[:create_model, :upload, :rehash, :log_error]", exception_class: NoMethodError }
   end
 
 =begin
-Rescue( handler: X )
+Rescue( SPECIFIC_EXCEPTION, handler: X )
 =end
   class RescueWithClassHandlerTest < Minitest::Spec
-    Memo = Class.new
+    Song = Class.new
+    module Song::Activity; end
 
     #:rescue-handler
     class MyHandler
@@ -78,23 +84,29 @@ Rescue( handler: X )
     #:rescue-handler end
 
     #:rescue
-    class Memo::Create < Trailblazer::Operation
-      step :find_model
-      step Rescue( RuntimeError, handler: MyHandler ) {
-        step :update
+    class Song::Activity::Create < Trailblazer::Activity::Railway
+      step :create_model
+      step Rescue(RuntimeError, handler: MyHandler) {
+        step :upload
         step :rehash
       }
       step :notify
       fail :log_error
       #~methods
-      include T.def_steps(:find_model, :update, :notify, :log_error)
+      include T.def_steps(:create_model, :upload, :notify, :log_error)
       include Rehash
       #~methods end
     end
     #:rescue 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] >} }
+    it { assert_invoke Song::Activity::Create, seq: "[:create_model, :upload, :rehash, :notify]" }
+    it { assert_invoke Song::Activity::Create, rehash_raise: RuntimeError, terminus: :failure, seq: "[:create_model, :upload, :rehash, :log_error]", exception_class: RuntimeError }
+    it do
+      # Since we don't catch NoMethodError, execution stops.
+      assert_raises NoMethodError do
+        Song::Activity::Create.invoke([{seq: {}, rehash_raise: NoMethodError}])
+      end
+    end
   end
 
   class RescueWithModuleHandlerTest < Minitest::Spec
@@ -119,7 +131,7 @@ Rescue( handler: X )
     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] >} }
+    it { Memo::Create.( { seq: [], rehash_raise: RuntimeError } ).inspect(:seq, :exception_class).must_equal %{<Result:false [[:find_model, :update, :rehash, :log_error], RuntimeError] >} }
   end
 
 =begin
@@ -149,7 +161,7 @@ Rescue( handler: :instance_method )
     #:rescue-method 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] >} }
+    it { Memo::Create.( { seq: [], rehash_raise: RuntimeError } ).inspect(:seq, :exception_class).must_equal %{<Result:false [[:find_model, :update, :rehash, :log_error], RuntimeError] >} }
   end
 
 =begin
@@ -176,4 +188,63 @@ Rescue(), fast_track: true {}
     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
+
+  class RescueIDTest < Minitest::Spec
+    class Validate
+      def self.call(*)
+
+      end
+    end
+
+    it "assigns ID via {Macro.id_for}" do
+      activity = Class.new(Trailblazer::Activity::Railway) do
+        step Rescue() {}
+        step Rescue(handler: Validate) {}
+        step Rescue(handler: :instance_method) {}
+        step Rescue() {}, id: "Rescue-1"
+        step Rescue(id: "Rescue-2") {}
+        # test identical configuration.
+        step Rescue() {}
+        step Rescue(handler: Validate) {}
+      end
+
+      # assert_equal Trailblazer::Developer::Introspect.find_path(activity, ["Each/EachIDTest::Validate"])[0].id, "Each/EachIDTest::Validate"
+      # assert_equal Trailblazer::Developer::Introspect.find_path(activity, ["Each-1"])[0].id,                    "Each-1"
+      # assert_equal Trailblazer::Developer::Introspect.find_path(activity, ["Each/composers_for_each"])[0].id,   "Each/composers_for_each"
+
+      assert_match /Rescue\/\d+/, Trailblazer::Activity::Introspect::Nodes(activity).values[1].id
+      assert_match /Rescue\/\d+/, Trailblazer::Activity::Introspect::Nodes(activity).values[2].id
+      assert_match /Rescue\/\d+/, Trailblazer::Activity::Introspect::Nodes(activity).values[3].id
+      assert_match "Rescue-1", Trailblazer::Activity::Introspect::Nodes(activity).values[4].id
+      assert_match "Rescue-2", Trailblazer::Activity::Introspect::Nodes(activity).values[5].id
+      assert_match /Rescue\/\d+/, Trailblazer::Activity::Introspect::Nodes(activity).values[6].id
+      assert_match /Rescue\/\d+/, Trailblazer::Activity::Introspect::Nodes(activity).values[7].id
+    end
+  end
+
+  class ComplianceTest < Minitest::Spec
+    it "tracing" do
+      activity = Class.new(Trailblazer::Activity::Railway) do
+        step Rescue(id: "Rescue/1") {
+          step :validate
+        }
+
+        def validate(ctx, validate: false, seq:, **)
+          seq << :validate
+          raise unless validate
+          validate
+        end
+      end
+
+      ctx = {validate: false}
+
+      output, _ = trace activity, ctx
+      assert_equal output, %(TOP
+|-- Start.default
+|-- Rescue/1
+|   |-- Start.default
+|   `-- validate
+`-- End.failure)
+    end
+  end
 end

data/test/docs/wrap_test.rb

@@ -169,9 +169,9 @@ When raise:   return {Railway.fail!}
   #@ happy days
     assert_invoke Memo::Create, seq: "[:model, :update, :rehash, :notify]"
   #@ rehash raises
-    assert_invoke Memo::Create, rehash_raise: true, seq: "[:model, :update, :rehash, :log_error]",
+    assert_invoke Memo::Create, rehash_raise: RuntimeError, seq: "[:model, :update, :rehash, :log_error]",
       terminus: :failure,
-      expected_ctx_variables: {exception: "nope!"}
+      expected_ctx_variables: {exception: "RuntimeError"}
   end
 
 =begin
@@ -205,7 +205,7 @@ When raise:   return {Railway.fail!}, but wire Wrap() to {fail_fast: true}
     end
 
     it { Memo::Create.( { seq: [] } ).inspect(:seq).must_equal %{<Result:true [[:model, :update, :rehash, :notify]] >} }
-    it { Memo::Create.( { seq: [], rehash_raise: true } ).inspect(:seq).must_equal %{<Result:false [[:model, :update, :rehash]] >} }
+    it { Memo::Create.( { seq: [], rehash_raise: RuntimeError } ).inspect(:seq).must_equal %{<Result:false [[:model, :update, :rehash]] >} }
   end
 
 =begin
@@ -242,7 +242,7 @@ When raise:   return {Railway.fail_fast!} and configure Wrap() to {fast_track: t
     #:fail-fast end
 
     it { Memo::Create.( { seq: [] } ).inspect(:seq).must_equal %{<Result:true [[:model, :update, :rehash, :notify]] >} }
-    it { Memo::Create.( { seq: [], rehash_raise: true } ).inspect(:seq).must_equal %{<Result:false [[:model, :update, :rehash]] >} }
+    it { Memo::Create.( { seq: [], rehash_raise: RuntimeError } ).inspect(:seq).must_equal %{<Result:false [[:model, :update, :rehash]] >} }
   end
 
 =begin
@@ -289,7 +289,7 @@ When raise:   return {Railway.fail!} or {Railway.pass!}
     end
 
     it do
-      result = Memo::Create.( { seq: [], rehash_raise: true } )
+      result = Memo::Create.( { seq: [], rehash_raise: RuntimeError } )
       result.inspect(:seq).must_equal %{<Result:false [[:model, :update, :rehash]] >}
       result.event.inspect.must_equal %{#<Trailblazer::Activity::End semantic=:transaction_failed>}
     end
@@ -326,7 +326,7 @@ When raise:   return {Railway.pass!} and go "successful"
     end
 
     it { Memo::Create.( { seq: [] } ).inspect(:seq).must_equal %{<Result:true [[:model, :update, :rehash, :notify]] >} }
-    it { Memo::Create.( { seq: [], rehash_raise: true } ).inspect(:seq).must_equal %{<Result:true [[:model, :update, :rehash, :notify]] >} }
+    it { Memo::Create.( { seq: [], rehash_raise: RuntimeError } ).inspect(:seq).must_equal %{<Result:true [[:model, :update, :rehash, :notify]] >} }
   end
 
 =begin
@@ -361,7 +361,7 @@ You can return boolean true in wrap.
     end
 
     it "translates true returned form a wrap to a signal with a `success` semantic" do
-      result = Memo::Create.( { seq: [], rehash_raise: true } )
+      result = Memo::Create.( { seq: [], rehash_raise: RuntimeError } )
       result.inspect(:seq).must_equal %{<Result:true [[:model, :update, :rehash, :notify]] >}
       result.event.inspect.must_equal %{#<Trailblazer::Activity::Railway::End::Success semantic=:success>}
     end
@@ -399,7 +399,7 @@ You can return boolean false in wrap.
     end
 
     it "translates false returned form a wrap to a signal with a `failure` semantic" do
-      result = Memo::Create.( { seq: [], rehash_raise: true } )
+      result = Memo::Create.( { seq: [], rehash_raise: RuntimeError } )
       result.inspect(:seq).must_equal %{<Result:false [[:model, :update, :rehash, :log_error]] >}
       result.event.inspect.must_equal %{#<Trailblazer::Activity::Railway::End::Failure semantic=:failure>}
     end
@@ -437,7 +437,7 @@ You can return nil in wrap.
     end
 
     it "translates nil returned form a wrap to a signal with a `failure` semantic" do
-      result = Memo::Create.( { seq: [], rehash_raise: true } )
+      result = Memo::Create.( { seq: [], rehash_raise: RuntimeError } )
       result.inspect(:seq).must_equal %{<Result:false [[:model, :update, :rehash, :log_error]] >}
       result.event.inspect.must_equal %{#<Trailblazer::Activity::Railway::End::Failure semantic=:failure>}
     end
@@ -484,7 +484,7 @@ This one is mostly to show how one could wrap steps in a transaction
     #:transaction end
 
     it { Memo::Create.( { seq: [] } ).inspect(:seq).must_equal %{<Result:true [[:model, :update, :rehash, :notify]] >} }
-    it { Memo::Create.( { seq: [], rehash_raise: true } ).inspect(:seq).must_equal %{<Result:false [[:model, :update, :rehash, :log_error]] >} }
+    it { Memo::Create.( { seq: [], rehash_raise: RuntimeError } ).inspect(:seq).must_equal %{<Result:false [[:model, :update, :rehash, :log_error]] >} }
   end
 
 =begin

data/test/test_helper.rb

@@ -17,7 +17,7 @@ end
 module Rehash
   def rehash(ctx, seq:, rehash_raise: false, **)
     seq << :rehash
-    raise "nope!" if rehash_raise
+    raise rehash_raise if rehash_raise
     true
   end
 end
@@ -27,6 +27,13 @@ Minitest::Spec.include Trailblazer::Activity::Testing::Assertions
 Minitest::Spec.class_eval do
   def trace(activity, ctx)
     stack, signal, (ctx, _) = Trailblazer::Developer::Trace.invoke(activity, [ctx, {}])
-    return Trailblazer::Developer::Trace::Present.(stack, node_options: {stack.to_a[0]=>{label: "TOP"}}).gsub(/:\d+/, ""), signal, ctx
+
+    output = Trailblazer::Developer::Trace::Present.(stack) do |trace_nodes:, **|
+      {node_options: {trace_nodes[0] => {label: "TOP"}}}
+    end.gsub(/:\d+/, "")
+
+    return output, signal, ctx
   end
 end
+
+# Trailblazer::Core.convert_operation_test("test/docs/composable_variable_mapping_test.rb")

data/trailblazer-macro.gemspec

@@ -19,8 +19,8 @@ Gem::Specification.new do |spec|
 
   spec.add_development_dependency "minitest"
   spec.add_development_dependency "rake"
-  spec.add_development_dependency "trailblazer-developer"
-  spec.add_dependency "trailblazer-operation", ">= 0.10.0" # TODO: this dependency will be removed. currently needed for tests and for Guard::Result
+  spec.add_development_dependency "trailblazer-developer", ">= 0.1.0", "< 0.2.0"
+  spec.add_dependency "trailblazer-operation", ">= 0.10.1" # TODO: this dependency will be removed. currently needed for tests and for Guard::Result
 
   spec.add_dependency "trailblazer-activity-dsl-linear", ">= 1.2.0", "< 1.3.0"
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: trailblazer-macro
 version: !ruby/object:Gem::Version
-  version: 2.1.14
+  version: 2.1.15
 platform: ruby
 authors:
 - Nick Sutterer
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-03-02 00:00:00.000000000 Z
+date: 2023-06-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -44,28 +44,34 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.1.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 0.2.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.1.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 0.2.0
 - !ruby/object:Gem::Dependency
   name: trailblazer-operation
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.10.0
+        version: 0.10.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.10.0
+        version: 0.10.1
 - !ruby/object:Gem::Dependency
   name: trailblazer-activity-dsl-linear
   requirement: !ruby/object:Gem::Requirement