trailblazer-macro 2.1.11 → 2.1.13

data/test/docs/wrap_test.rb

@@ -1,5 +1,137 @@
 require "test_helper"
 
+  #@ yield returns a circuit-interface result set, we can return it to the flow
+#:my_transaction
+class MyTransaction
+  def self.call((ctx, flow_options), **, &block)
+    signal, (ctx, flow_options) = yield # calls the wrapped steps
+
+    return signal, [ctx, flow_options]
+  end
+end
+#:my_transaction end
+
+class WrapSimpleHandlerTest < Minitest::Spec
+  MyTransaction = ::MyTransaction
+
+  class Song
+  end
+
+  #:upload
+  module Song::Activity
+    class Upload < Trailblazer::Activity::FastTrack
+      step :model
+      step Wrap(MyTransaction) {
+        step :update   # this changes the database.
+        step :transfer # this might even break!
+      }
+      step :notify
+      fail :log_error
+      #~meths
+      include T.def_steps(:model, :update, :transfer, :notify, :log_error)
+      #~meths end
+    end
+  end
+  #:upload end
+
+  it do
+  #@ happy days
+    assert_invoke Song::Activity::Upload, seq: "[:model, :update, :transfer, :notify]"
+  #@ transfer returns false
+    assert_invoke Song::Activity::Upload, transfer: false, seq: "[:model, :update, :transfer, :log_error]",
+      terminus: :failure
+  end
+end
+
+class WrapSimpleHandlerRoutesCustomTerminsTest < Minitest::Spec
+  MyTransaction = WrapSimpleHandlerTest::MyTransaction
+
+  class Song
+  end
+
+  module Song::Activity
+    class Upload < Trailblazer::Activity::FastTrack
+      step :model
+      #:out
+      #:out-wrap
+      step Wrap(MyTransaction) {
+        step :update   # this changes the database.
+        step :transfer,
+          Output(:failure) => End(:timeout) # creates a third terminus.
+      },
+      #:out-wrap end
+        Output(:timeout) => Track(:fail_fast) # any wiring is possible here.
+      #:out end
+      step :notify
+      fail :log_error
+      #~meths
+      include T.def_steps(:model, :update, :transfer, :notify, :log_error)
+      #~meths end
+    end
+  end
+
+  it do
+  #@ happy days
+    assert_invoke Song::Activity::Upload, seq: "[:model, :update, :transfer, :notify]"
+  #@ transfer returns false
+    assert_invoke Song::Activity::Upload, transfer: false, seq: "[:model, :update, :transfer]",
+      terminus: :fail_fast
+  #@ update returns false
+    assert_invoke Song::Activity::Upload, update: false, seq: "[:model, :update, :log_error]",
+      terminus: :failure
+  end
+end
+
+#@ handler uses rescue. Pretty sure we got identical tests below.
+class WrapMyRescueTest < Minitest::Spec
+  #:my_rescue
+  class MyRescue
+    def self.call((ctx, flow_options), **, &block)
+      signal, (ctx, flow_options) = yield # calls the wrapped steps
+
+      return signal, [ctx, flow_options]
+    rescue
+      ctx[:exception] = $!.message
+      return Trailblazer::Activity::Left, [ctx, flow_options]
+    end
+  end
+  #:my_rescue end
+
+  class Song
+  end
+
+  #:upload-rescue
+  module Song::Activity
+    class Upload < Trailblazer::Activity::FastTrack
+      step :model
+      step Wrap(MyRescue) {
+        step :update
+        step :transfer # might raise an exception.
+      }
+      step :notify
+      fail :log_error
+      #~meths
+      include T.def_steps(:model, :update, :transfer, :notify, :log_error)
+      def transfer(ctx, seq:, transfer: true, **)
+        seq << :transfer
+        raise RuntimeError.new("transfer failed") unless transfer
+        transfer
+      end
+      #~meths end
+    end
+  end
+  #:upload-rescue end
+
+  it do
+  #@ happy days
+    assert_invoke Song::Activity::Upload, seq: "[:model, :update, :transfer, :notify]"
+  #@ transfer raises
+    assert_invoke Song::Activity::Upload, transfer: false, seq: "[:model, :update, :transfer, :log_error]",
+      terminus: :failure,
+      expected_ctx_variables: {exception: "transfer failed"}
+  end
+end
+
 class DocsWrapTest < Minitest::Spec
 =begin
 When success: return the block's returns
@@ -8,7 +140,8 @@ When raise:   return {Railway.fail!}
   #:wrap-handler
   class HandleUnsafeProcess
     def self.call((ctx, flow_options), *, &block)
-      yield # calls the wrapped steps
+      signal, (ctx, flow_options) = yield # calls the wrapped steps
+      return signal, [ctx, flow_options]
     rescue
       ctx[:exception] = $!.message
       [ Trailblazer::Operation::Railway.fail!, [ctx, flow_options] ]
@@ -18,7 +151,7 @@ When raise:   return {Railway.fail!}
 
   #:wrap
   class Memo::Create < Trailblazer::Operation
-    step :find_model
+    step :model
     step Wrap( HandleUnsafeProcess ) {
       step :update
       step :rehash
@@ -26,45 +159,21 @@ When raise:   return {Railway.fail!}
     step :notify
     fail :log_error
     #~methods
-    include T.def_steps(:find_model, :update, :notify, :log_error)
+    include T.def_steps(:model, :update, :notify, :log_error)
     include Rehash
     #~methods end
   end
   #:wrap 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]] >} }
-
-=begin
-Tracing with Wrap()
-=end
   it do
-    options = { seq: [] }
-    #:trace-call
-    result  = Memo::Create.trace( options )
-    #:trace-call end
-    result.wtf.gsub("\n", "").must_match /.*Start.*find_model.*Wrap.*update.*rehash.*success.*notify.*success/
-=begin
-#:trace-success
-result.wtf? #=>
-|-- #<Trailblazer::Activity::Start semantic=:default>
-|-- find_model
-|-- Wrap/85
-|   |-- #<Trailblazer::Activity::Start semantic=:default>
-|   |-- update
-|   |-- rehash
-|   `-- #<Trailblazer::Operation::Railway::End::Success semantic=:success>
-|-- notify
-`-- #<Trailblazer::Operation::Railway::End::Success semantic=:success>
-#:trace-success end
-=end
+  #@ 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]",
+      terminus: :failure,
+      expected_ctx_variables: {exception: "nope!"}
   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}
@@ -81,7 +190,7 @@ When raise:   return {Railway.fail!}, but wire Wrap() to {fail_fast: true}
         end
       end
 
-      step :find_model
+      step :model
       step Wrap( HandleUnsafeProcess ) {
         step :update
         step :rehash
@@ -90,13 +199,13 @@ When raise:   return {Railway.fail!}, but wire Wrap() to {fail_fast: true}
       fail :log_error
 
       #~methods
-      include T.def_steps(:find_model, :update, :notify, :log_error)
+      include T.def_steps(:model, :update, :notify, :log_error)
       include Rehash
       #~methods end
     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]] >} }
+    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]] >} }
   end
 
 =begin
@@ -118,7 +227,7 @@ When raise:   return {Railway.fail_fast!} and configure Wrap() to {fast_track: t
 
     #:fail-fast
     class Memo::Create < Trailblazer::Operation
-      step :find_model
+      step :model
       step Wrap( HandleUnsafeProcess ) {
         step :update
         step :rehash
@@ -126,14 +235,14 @@ When raise:   return {Railway.fail_fast!} and configure Wrap() to {fast_track: t
       step :notify
       fail :log_error
       #~methods
-      include T.def_steps(:find_model, :update, :notify, :log_error)
+      include T.def_steps(:model, :update, :notify, :log_error)
       include Rehash
       #~methods end
     end
     #:fail-fast 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]] >} }
+    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]] >} }
   end
 
 =begin
@@ -157,7 +266,7 @@ When raise:   return {Railway.fail!} or {Railway.pass!}
 
     #:custom
     class Memo::Create < Trailblazer::Operation
-      step :find_model
+      step :model
       step Wrap( MyTransaction ) {
         step :update
         step :rehash
@@ -167,7 +276,7 @@ When raise:   return {Railway.fail!} or {Railway.pass!}
       step :notify
       fail :log_error
       #~methods
-      include T.def_steps(:find_model, :update, :notify, :log_error)
+      include T.def_steps(:model, :update, :notify, :log_error)
       include Rehash
       #~methods end
     end
@@ -175,13 +284,13 @@ When raise:   return {Railway.fail!} or {Railway.pass!}
 
     it do
       result = Memo::Create.( { seq: [] } )
-      result.inspect(:seq).must_equal %{<Result:false [[:find_model, :update, :rehash]] >}
+      result.inspect(:seq).must_equal %{<Result:false [[:model, :update, :rehash]] >}
       result.event.inspect.must_equal %{#<Trailblazer::Activity::End semantic=:transaction_worked>}
     end
 
     it do
       result = Memo::Create.( { seq: [], rehash_raise: true } )
-      result.inspect(:seq).must_equal %{<Result:false [[:find_model, :update, :rehash]] >}
+      result.inspect(:seq).must_equal %{<Result:false [[:model, :update, :rehash]] >}
       result.event.inspect.must_equal %{#<Trailblazer::Activity::End semantic=:transaction_failed>}
     end
   end
@@ -202,7 +311,7 @@ When raise:   return {Railway.pass!} and go "successful"
         end
       end
 
-      step :find_model
+      step :model
       step Wrap( HandleUnsafeProcess ) {
         step :update
         step :rehash
@@ -211,13 +320,13 @@ When raise:   return {Railway.pass!} and go "successful"
       fail :log_error
 
       #~methods
-      include T.def_steps(:find_model, :update, :notify, :log_error)
+      include T.def_steps(:model, :update, :notify, :log_error)
       include Rehash
       #~methods end
     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: [] } ).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]] >} }
   end
 
 =begin
@@ -237,7 +346,7 @@ You can return boolean true in wrap.
         end
       end
 
-      step :find_model
+      step :model
       step Wrap( HandleUnsafeProcess ) {
         step :update
         step :rehash
@@ -246,14 +355,14 @@ You can return boolean true in wrap.
       fail :log_error
 
       #~methods
-      include T.def_steps(:find_model, :update, :notify, :log_error)
+      include T.def_steps(:model, :update, :notify, :log_error)
       include Rehash
       #~methods end
     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.inspect(:seq).must_equal %{<Result:true [[:model, :update, :rehash, :notify]] >}
       result.event.inspect.must_equal %{#<Trailblazer::Activity::Railway::End::Success semantic=:success>}
     end
   end
@@ -275,7 +384,7 @@ You can return boolean false in wrap.
         end
       end
 
-      step :find_model
+      step :model
       step Wrap( HandleUnsafeProcess ) {
         step :update
         step :rehash
@@ -284,14 +393,14 @@ You can return boolean false in wrap.
       fail :log_error
 
       #~methods
-      include T.def_steps(:find_model, :update, :notify, :log_error)
+      include T.def_steps(:model, :update, :notify, :log_error)
       include Rehash
       #~methods end
     end
 
     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, :log_error]] >}
+      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
   end
@@ -313,7 +422,7 @@ You can return nil in wrap.
         end
       end
 
-      step :find_model
+      step :model
       step Wrap( HandleUnsafeProcess ) {
         step :update
         step :rehash
@@ -322,14 +431,14 @@ You can return nil in wrap.
       fail :log_error
 
       #~methods
-      include T.def_steps(:find_model, :update, :notify, :log_error)
+      include T.def_steps(:model, :update, :notify, :log_error)
       include Rehash
       #~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.inspect(:seq).must_equal %{<Result:false [[:model, :update, :rehash, :log_error]] >}
       result.event.inspect.must_equal %{#<Trailblazer::Activity::Railway::End::Failure semantic=:failure>}
     end
   end
@@ -360,7 +469,7 @@ This one is mostly to show how one could wrap steps in a transaction
 
     #:transaction
     class Memo::Create < Trailblazer::Operation
-      step :find_model
+      step :model
       step Wrap( MyTransaction ) {
         step :update
         step :rehash
@@ -368,14 +477,14 @@ This one is mostly to show how one could wrap steps in a transaction
       step :notify
       fail :log_error
       #~methods
-      include T.def_steps(:find_model, :update, :notify, :log_error)
+      include T.def_steps(: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: [] } ).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]] >} }
   end
 
 =begin
@@ -402,19 +511,192 @@ This one is mostly to show how one could evaluate Wrap()'s return value based on
 
     #:transaction
     class Memo::Create < Trailblazer::Operation
-      step :find_model
+      step :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)
+      include T.def_steps(: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]] >} }
+    it { Memo::Create.( { seq: [] } ).inspect(:seq).must_equal %{<Result:true [[:model, :update]] >} }
+    it { Memo::Create.( { seq: [], update: false } ).inspect(:seq).must_equal %{<Result:false [[:model, :update, :log_error]] >} }
+  end
+
+
+  class WrapOperationWithCustomTerminus < Minitest::Spec
+    Song = Module.new
+
+    module Song::Activity
+      class HandleUnsafeProcess
+        def self.call((ctx), *, &block)
+          yield # calls the wrapped steps
+        rescue
+          [ Trailblazer::Operation::Railway.fail_fast!, [ctx, {}] ]
+        end
+      end
+
+      class Upload < Trailblazer::Activity::FastTrack
+        step :model
+        step Wrap(HandleUnsafeProcess) {
+          step :send_request,
+            Output(:failure) => End(:timeout__) # adds a terminus {End.timeout}
+          # step :rehash
+        },
+          Output(:timeout__) => Track(:fail_fast)
+        step :upload
+        fail :log_error
+        #~methods
+        include T.def_steps(:model, :send_request, :upload, :log_error)
+        #~methods end
+      end
+    end
+
+    it do
+    #@ success path
+      assert_invoke Song::Activity::Upload, seq: "[:model, :send_request, :upload]"
+    #@ we travel through {:timeout}
+      assert_invoke Song::Activity::Upload, send_request: false, seq: "[:model, :send_request]", terminus: :fail_fast
+    end
+
+    it "tracing" do
+      assert_equal trace(Song::Activity::Upload, {seq: []})[0], %{TOP
+|-- Start.default
+|-- model
+|-- Wrap/DocsWrapTest::WrapOperationWithCustomTerminus::Song::Activity::HandleUnsafeProcess
+|   |-- Start.default
+|   |-- send_request
+|   `-- End.success
+|-- upload
+`-- End.success}
+
+  #@ compile time
+  #@ make sure we can find tasks/compile-time artifacts in Wrap by using their {compile_id}.
+    # assert_equal Trailblazer::Developer::Introspect.find_path(Song::Activity::Upload,
+    #   [Wrap])[0].task.inspect,
+    #   %{#<Trailblazer::Activity::TaskBuilder::Task user_proc=compute_item>}
+    # puts Trailblazer::Developer::Render::TaskWrap.(activity, ["Each/1", "Each.iterate.block", "invoke_block_activity", :compute_item])
+
+    end
+  end
+end
+
+class WrapUnitTest < Minitest::Spec
+  class HandleUnsafeProcess
+    def self.call((ctx, flow_options), **, &block)
+      yield # calls the wrapped steps
+    end
+  end
+
+  it "assigns IDs via {Macro.id_for}" do
+    activity = Class.new(Trailblazer::Activity::Railway) do
+      def self.my_wrap_handler((ctx, flow_options), **, &block)
+        yield # calls the wrapped steps
+      end
+
+      my_wrap_handler = ->((ctx, flow_options), **, &block) do
+        block.call # calls the wrapped steps
+      end
+
+      step Wrap(HandleUnsafeProcess) {}
+      # step Wrap(:my_wrap_handler) {} # FIXME: this doesn't work, yet.
+      step Wrap(method(:my_wrap_handler)) {}
+      step Wrap(my_wrap_handler) {}, id: "proc:my_wrap_handler"
+    end
+
+    [
+      "Wrap/WrapUnitTest::HandleUnsafeProcess",
+      "Wrap/method(:my_wrap_handler)",
+      "proc:my_wrap_handler"
+    ].each do |id|
+      assert_equal Trailblazer::Developer::Introspect.find_path(activity, [id])[0].id, id
+    end
+
+    assert_equal trace(activity, {seq: []})[0], %{TOP
+|-- Start.default
+|-- Wrap/WrapUnitTest::HandleUnsafeProcess
+|   |-- Start.default
+|   `-- End.success
+|-- Wrap/method(:my_wrap_handler)
+|   |-- Start.default
+|   `-- End.success
+|-- proc:my_wrap_handler
+|   |-- Start.default
+|   `-- End.success
+`-- End.success}
+  end
+
+  it "complies with Introspect API/Patch API" do
+    class MyValidation < Trailblazer::Activity::Railway
+      step :validate
+      include T.def_steps(:validate)
+    end
+
+    activity = Class.new(Trailblazer::Activity::Railway) do
+      step Wrap(HandleUnsafeProcess) {
+        step Subprocess(MyValidation), id: :validation
+      }
+    end
+
+    mock_validation = ->(ctx, seq:, **) { ctx[:seq] = seq + [:mock_validation] }
+
+    #@ Introspect::TaskMap  interface
+    assert_equal Trailblazer::Developer::Introspect.find_path(activity,
+      ["Wrap/WrapUnitTest::HandleUnsafeProcess", :validation, :validate])[0].task.inspect,
+      %{#<Trailblazer::Activity::TaskBuilder::Task user_proc=validate>}
+
+    #@ Patch interface
+    patched_activity = Trailblazer::Activity::DSL::Linear.Patch(
+      activity,
+      ["Wrap/WrapUnitTest::HandleUnsafeProcess"] => -> { step mock_validation, replace: :validation, id: :validation }
+    )
+
+    #@ the original activity with Wrap is unchanged.
+    assert_invoke activity, seq: %{[:validate]}
+
+    #@ the patched version only runs {mock_validation}.
+    assert_invoke patched_activity, seq: %{[:mock_validation]}
+  end
+end
+
+class WrapStrategyComplianceTest < Minitest::Spec
+  Song = WrapSimpleHandlerTest::Song
+
+  it do
+    #:patch
+    upload_with_upsert = Trailblazer::Activity::DSL::Linear.Patch(
+      Song::Activity::Upload,
+      ["Wrap/MyTransaction"] => -> { step :upsert, replace: :update }
+    )
+    #:patch end
+    upload_with_upsert.include(T.def_steps(:upsert))
+
+  #@ Original class isn't changed.
+    assert_invoke Song::Activity::Upload, seq: "[:model, :update, :transfer, :notify]"
+  #@ Patched class runs
+    assert_invoke upload_with_upsert, seq: "[:model, :upsert, :transfer, :notify]"
+  end
+
+  it "find_path" do
+    assert_equal Trailblazer::Developer::Introspect.find_path(Song::Activity::Upload,
+      ["Wrap/MyTransaction", :transfer])[0].task.inspect,
+      %{#<Trailblazer::Activity::TaskBuilder::Task user_proc=transfer>}
+
+=begin
+#:find_path
+node, _ = Trailblazer::Developer::Introspect.find_path(
+  Song::Activity::Upload,
+  ["Wrap/MyTransaction", :transfer])
+#=> #<Node ...>
+#:find_path end
+=end
+  end
+
+  it "tracing" do
+    # Trailblazer::Developer.wtf?(Song::Activity::Upload, {seq: []})
   end
 end

data/test/test_helper.rb

@@ -44,3 +44,32 @@ module Rehash
     true
   end
 end
+
+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
+  end
+end
+
+
+
+# signal, (ctx, _) = Trailblazer::Activity.(Song::Activity::Create,
+#       params:               {title: "Olympia"}, # some random variable.
+#       "model.class":        Hit,
+#       "model.action":       :find_by,
+#       "model.find_by_key":  :title, seq: []
+#     )
+
+# #:update-ok
+#     signal, (ctx, _) = Trailblazer::Activity.(Song::Activity::Update, params: {id: 1}, seq: [])
+#     ctx[:model] #=> #<Song id=1, ...>
+#     puts signal #=> #<Trailblazer::Activity::End semantic=:success>
+# #:update-ok end
+
+
+# require "trailblazer/core"
+# Trailblazer::Core.convert_operation_test("test/docs/model_test.rb")
+# Trailblazer::Core.convert_operation_test("test/docs/each_test.rb")

data/trailblazer-macro.gemspec

@@ -17,16 +17,12 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
-  spec.add_development_dependency "bundler"
   spec.add_development_dependency "minitest"
   spec.add_development_dependency "rake"
-
-  spec.add_development_dependency "multi_json"
-  spec.add_development_dependency "roar"
   spec.add_development_dependency "trailblazer-developer"
 
-  spec.add_dependency "trailblazer-activity-dsl-linear", ">= 1.0.0", "< 1.1.0"
-  spec.add_dependency "trailblazer-operation", ">= 0.8.0" # TODO: this dependency will be removed. currently needed for tests?!
+  spec.add_dependency "trailblazer-activity-dsl-linear", ">= 1.1.0", "< 1.2.0"
+  spec.add_dependency "trailblazer-operation", ">= 0.9.0" # TODO: this dependency will be removed. currently needed for tests?! and for Guard::Result
 
   spec.required_ruby_version = ">= 2.2.0"
 end