trailblazer-macro 2.1.14 → 2.1.16

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bdbc731c17b52586de5a713605423d506a6ea91866db65f4a04be858fa5afb1e
-  data.tar.gz: 254f4e89aca81b120e6f1392c99ac30dfe9dd70cde79e2f2a9aa669a88448bfb
+  metadata.gz: 2de3e28697d847ca2ffb3f49b595955c58a6a4495f0896b4b280016094115507
+  data.tar.gz: 91ccc278f803d068dc21b25dd02e8e3dc8d2842931309e58dcee21163667b7c2
 SHA512:
-  metadata.gz: d0b26e20fe1f14def81e30ca0a39a37cf58b6257530307bb9db1f80d914c04b8c5dfb4143f98c012a0605074f31c1cf42b91930aeaecd1cf8f820158cfac6ee4
-  data.tar.gz: cdee315a8ac8900bf438694f7320b88cd3ceb32436baf544826bb550289f56a466ef18da3142ef15e1bde8eb3fc575eadb87e6670106c6be204e921d1285ab00
+  metadata.gz: 58028a68a5cdc8c0da14209657b4e7b7aed56543f8022c58622db04dddb2a21fe5b42ded72c8ab38deedb76e34e6e027250b76bf5031a17e1af7d22a0f540706
+  data.tar.gz: 8803eb8c3640359c889c7eed9eb9e78bbd362f06edd9f28bdf0dc47690956d7f70f7cb128ae0fe7bcaa7a4301eeda8833b119218f8ce0ee5d1ffd526d96df1f1

data/CHANGES.md

@@ -1,3 +1,15 @@
+# 2.1.16
+
+* Fix a bug in `patch` where `Subprocess()` was missing in `Macro::Strategy`.
+* Introduce `Model::Build` and `Model::Find` macros, which are a replacement for the less
+  customizable `Model()`. See https://trailblazer.to/2.1/docs/macro/#macro-model-model-find
+
+# 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,14 +4,15 @@ 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"
 
-# gem "trailblazer-activity-dsl-linear",  path: "../trailblazer-activity-dsl-linear"
+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/model/find.rb

@@ -0,0 +1,175 @@
+module Trailblazer
+  module Macro
+    class Model
+      # New API for retrieving models by ID.
+      # Only handles keyword argument style.
+      #
+      #
+      # DESIGN NOTES
+      #   * params[:id] extraction and the actual query are two separate components in the final finder activity.
+      def self.Find(model_class, positional_method = nil, find_method: nil, id: "model.find", not_found_terminus: false, query: nil, **keyword_options, &block)
+      # 1. optional: translate kws/positionals into local kws
+      # 2. build :query
+      # 3. build find activity
+
+        # raise "unknown options #{keyword_options}" if keyword_options.size > 1
+
+        params_key, block, finder_step_options =
+          if positional_method
+            for_explicit_positional(model_class, positional_method, **keyword_options, &block)
+          elsif find_method.nil? && query.nil? # translate_from_shorthand
+            for_shorthand(model_class, **keyword_options, &block)
+          else # options passed explicitly, kws. this still means we need to translate find_method to query, or use user's query.
+            # TODO: sort out query: default it or take user's
+
+            if query.nil?
+              for_keywords(model_class, find_method: find_method, **keyword_options, &block)
+            else
+              # raise "IMPLEMENT ME"
+              for_query(model_class, query, **keyword_options, &block)
+            end
+          end
+
+        task = finder_activity_for(
+          params_key: params_key,
+          finder:     finder_step_options,
+          &block
+        )
+
+        options = options_for(task, id: id)
+
+        options = options.merge(Activity::Railway.Output(:failure) => Activity::Railway.End(:not_found)) if not_found_terminus
+
+        options
+      end
+
+      # Defaulting happening.
+      def self.normalize_keys(column_key: :id, params_key: column_key, **)
+        return params_key, column_key
+      end
+
+      def self.for_shorthand(model_class, **options, &block)
+        # translate shorthand form.
+        find_method_name, column_key = options.to_a[0]
+
+        params_key = options.key?(:params_key) ? options[:params_key] : column_key # TODO: use method for this.
+
+        [
+          params_key,
+          block,
+          Find::KeywordArguments.new(model_class: model_class, find_method: find_method_name, column_key: column_key),
+        ]
+      end
+
+      def self.for_explicit_positional(model_class, positional_method, **options, &block)
+        params_key, _ = normalize_keys(**options)
+
+        [
+          params_key,
+          block,
+          Find::Positional.new(model_class: model_class, find_method: positional_method), # query
+        ]
+      end
+
+      def self.for_keywords(model_class, find_method:, **options, &block) # FIXME: defaulting is redundant with bla_explicit_positional.
+        params_key, column_key = normalize_keys(**options)
+
+        finder = Find::KeywordArguments.new(model_class: model_class, find_method: find_method, column_key: column_key)
+
+        [params_key, block, finder]
+      end
+
+      def self.for_query(model_class, query, column_key: :id, params_key: column_key, **, &block) # FIXME: defaulting is redundant with bla_explicit_positional.
+        query_on_model_class = ->(ctx, **kws) { model_class.instance_exec(ctx, **kws, &query) } # FIXME: we can only use procs here. what about methods, classes etc?
+
+        finder = Macro.task_adapter_for_decider(query_on_model_class, variable_name: :model) # FIXME: {:model} is hard-coded.
+
+        [
+          params_key,
+          block,
+          {task: finder} # circuit interface for the Task::Adapter.
+        ]
+      end
+
+      def self.options_for(task, id:)
+        options = Activity::Railway.Subprocess(task).merge(id: id)
+
+        inject = {
+          Activity::Railway.Inject() => [:params], # pass-through {:params} if it's in ctx.
+        }
+
+        out = { # TODO: use Outject once it is implemented.
+          Activity::Railway.Out() => ->(ctx, **) { ctx.key?(:model) ? {model: ctx[:model]} : {} }
+        }
+
+        options = options.merge(inject)
+        options = options.merge(out)
+      end
+
+      # Finder activity consists of two steps:
+      # {extract_id}, and the finder code.
+      #
+      #   |-- model.build
+      #   |   |-- Start.default
+      #   |   |-- extract_id
+      #   |   |-- finder.Trailblazer::Macro::Model::Find::Positional
+      #   |   `-- End.success
+      #   |-- validate
+      def self.finder_activity_for(params_key:, finder:, **, &block)
+        id_from =
+          if block
+            block
+          else
+            ->(ctx, params: {}, **) { params[params_key] } # default id_from
+          end
+
+        extract_id = Macro.task_adapter_for_decider(id_from, variable_name: :id)
+
+        Class.new(Activity::Railway) do
+          step task: extract_id, id: :extract_id
+          step finder,           id: "finder.#{finder.class}" # FIXME: discuss ID.
+        end
+      end
+
+      # Runtime code.
+      module Find
+        class Positional
+          def initialize(model_class:, find_method:)
+            @model_class = model_class
+            @find_method = find_method
+          end
+
+          def call(ctx, id:, **)
+            ctx[:model] = @model_class.send(@find_method, id)
+          end
+        end
+
+        class KeywordArguments
+          def initialize(model_class:, find_method:, column_key:)
+            @model_class = model_class
+            @find_method = find_method
+            @column_key  = column_key.to_sym
+          end
+
+          def call(ctx, id:, **)
+            ctx[:model] = @model_class.send(@find_method, @column_key => id)
+          end
+        end
+
+        class NoArgument < Positional
+          def call(ctx, **)
+            ctx[:model] = @model_class.send(@find_method)
+          end
+        end
+      end # Find
+
+      def self.Build(model_class, method = :new, id: "model.build")
+        activity = Class.new(Activity::Railway) do
+          step Find::NoArgument.new(model_class: model_class, find_method: method)
+        end
+
+        options_for(activity, id: id)
+      end
+    end
+  end
+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(1000))
+      end
     end
   end
 end

data/lib/trailblazer/macro/strategy.rb

@@ -4,7 +4,7 @@ module Trailblazer
     class Strategy # We want to look like a real {Linear::Strategy}.
       class << self
         extend Forwardable
-        def_delegators :block_activity, :step, :pass, :fail # TODO: add all DSL::Helper
+        def_delegators :block_activity, :step, :pass, :fail, :Subprocess # TODO: add all DSL::Helper
       end
 
       # This makes {Wrap} look like {block_activity}.

data/lib/trailblazer/macro/version.rb

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

data/lib/trailblazer/macro.rb

@@ -4,6 +4,7 @@ require "trailblazer/operation" # TODO: remove this dependency
 
 require "trailblazer/macro/strategy"
 require "trailblazer/macro/model"
+require "trailblazer/macro/model/find"
 require "trailblazer/macro/policy"
 require "trailblazer/macro/guard"
 require "trailblazer/macro/pundit"
@@ -51,8 +52,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 +67,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
 
@@ -70,6 +80,7 @@ module Trailblazer
 
   module Activity::DSL::Linear::Helper
     Constants::Policy = Trailblazer::Macro::Policy
+    Constants::Model  = Trailblazer::Macro::Model
 
     # Extending the {Linear::Helper} namespace is the canonical way to import
     # macros into Railway, FastTrack, Operation, etc.

data/test/docs/autogenerated/operation_each_test.rb

@@ -190,6 +190,7 @@ class EachTest < Minitest::Spec
 
   it "{item_key: :composer}" do
     E::Mailer.send_options = []
+
     assert_invoke E::Song::Operation::Cover, params: {id: 1},
       expected_ctx_variables: {
         model: B::Song.find_by(id: 1),
@@ -287,6 +288,7 @@ class EachTest < Minitest::Spec
 
   it "Each(Activity::Railway)" do
     D::Mailer.send_options = []
+
     assert_invoke D::Song::Operation::Cover, params: {id: 1},
       seq:                    "[:rearrange]",
       expected_ctx_variables: {

data/test/docs/autogenerated/operation_model_test.rb

@@ -113,6 +113,7 @@ class DocsModelFindByTitleTest < Minitest::Spec
   it do
     #:key-title-fail
     result = Song::Operation::Update.(params: {title: nil}, seq: [])
+
     assert_equal result[:model].inspect, %{nil}
     #:key-title-fail end
   end
@@ -204,6 +205,7 @@ class DocsModelEmptyDITest < Minitest::Spec
 
   it do
     result = Song::Operation::Create.(params: {}, :"model.class" => Hit, seq: [])
+
     assert_equal result[:model].inspect, %{#<struct #{Hit} id=nil, title=nil>}
   end
 end
@@ -224,15 +226,16 @@ class DocsModelIOTest < Minitest::Spec
     #:in end
 
     result = Song::Operation::Create.(params: {}, my_id: 1, :"model.class" => Hit)
+
     assert_equal result[:model].inspect, %{#<struct #{Hit} id=1, title=nil>}
 =begin
 #:in-call
 result = Create.(my_id: 1)
 #:in-call end
 =end
-    end
   end
 end
+end
 
 class Model404TerminusTest < Minitest::Spec
   Song = Class.new(DocsModelTest::Song)

data/test/docs/each_test.rb

@@ -191,6 +191,7 @@ class EachTest < Minitest::Spec
 
   it "{item_key: :composer}" do
     E::Mailer.send_options = []
+
     assert_invoke E::Song::Activity::Cover, params: {id: 1},
       expected_ctx_variables: {
         model: B::Song.find_by(id: 1),
@@ -288,6 +289,7 @@ class EachTest < Minitest::Spec
 
   it "Each(Activity::Railway)" do
     D::Mailer.send_options = []
+
     assert_invoke D::Song::Activity::Cover, params: {id: 1},
       seq:                    "[:rearrange]",
       expected_ctx_variables: {
@@ -600,7 +602,7 @@ class EachStrategyComplianceTest < Minitest::Spec
     cover_patched.include(T.def_steps(:log_email, :notify_composers))
 
   #@ Original class isn't changed.
-    assert_invoke Song::Activity::Cover, params: {id: 1}, seq: [],
+    assert_invoke Song::Activity::Cover, params: {id: 1},
       expected_ctx_variables: {
           model: Song.find_by(id: 1),
         },
@@ -608,7 +610,7 @@ class EachStrategyComplianceTest < Minitest::Spec
 
   #@ Patched class runs
   # Trailblazer::Developer.wtf?(cover_patched, [params: {id: 1}, seq: []])
-    assert_invoke cover_patched, params: {id: 1}, seq: [],
+    assert_invoke cover_patched, params: {id: 1},
       expected_ctx_variables: {
           model: Song.find_by(id: 1),
         },
@@ -740,8 +742,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
@@ -786,6 +791,7 @@ class DocsEachUnitTest < Minitest::Spec
 
     # signal, (_ctx, _) = Trailblazer::Activity::TaskWrap.invoke(activity, [ctx])
     signal, (_ctx, _) = Trailblazer::Developer.wtf?(activity, [ctx], exec_context: my_exec_context)
+
     assert_equal _ctx[:collected_from_each], ["1-0", "2-1", "3-2"]
   end
 
@@ -823,6 +829,7 @@ class DocsEachUnitTest < Minitest::Spec
         },
       {}]
     )
+
     assert_invoke activity, dataset: ["one", "two", "three"], current_user: Object, expected_ctx_variables: {collected_from_each: ["one-0-Object", "two-1-Object", "three-2-Object"]}
   end
 
@@ -898,6 +905,7 @@ class DocsEachUnitTest < Minitest::Spec
 
     #@ fail at 3 but still collect 3rd iteration!
     Trailblazer::Developer.wtf?(activity, [{dataset: [1,2,3]}, {}])
+
     assert_invoke activity, dataset: [1,2,3],
       expected_ctx_variables: {collected_from_each: ["1", "2", "3"]},
       seq: "[]",

data/test/docs/guard_test.rb

@@ -16,12 +16,13 @@ class DocsGuardProcTest < Minitest::Spec
   end
   #:proc end
 
-  it { Create.(pass: false)[:x].must_be_nil }
-  it { Create.(pass: true)[:x].must_equal true }
+  it { assert_nil Create.(pass: false)[:x] }
+
+  it { assert_equal Create.(pass: true)[:x], true }
 
   #- result object, guard
-  it { Create.(pass: true)[:"result.policy.default"].success?.must_equal true }
-  it { Create.(pass: false)[:"result.policy.default"].success?.must_equal false }
+  it { assert_equal Create.(pass: true)[:"result.policy.default"].success?, true }
+  it { assert_equal Create.(pass: false)[:"result.policy.default"].success?, false }
 
   #---
   #- Guard inheritance
@@ -29,7 +30,7 @@ class DocsGuardProcTest < Minitest::Spec
     step Policy::Guard( ->(options, current_user:, **) { current_user } ), override: true
   end
 
-  it { Trailblazer::Developer.railway(New).must_equal %{[>policy.default.eval,>process]} }
+  it { assert_equal Trailblazer::Developer.railway(New), %{[>policy.default.eval,>process]} }
 end
 
 #---
@@ -58,8 +59,9 @@ class DocsGuardTest < Minitest::Spec
   end
   #:callable-op end
 
-  it { Create.(pass: false)[:x].must_be_nil }
-  it { Create.(pass: true)[:x].must_equal true }
+  it { assert_nil Create.(pass: false)[:x] }
+
+  it { assert_equal Create.(pass: true)[:x], true }
 end
 
 #---
@@ -83,8 +85,8 @@ class DocsGuardMethodTest < Minitest::Spec
   end
   #:method end
 
-  it { Create.(pass: false).inspect(:x).must_equal %{<Result:false [nil] >} }
-  it { Create.(pass: true).inspect(:x).must_equal %{<Result:true [true] >} }
+  it { assert_equal Create.(pass: false).inspect(:x), %{<Result:false [nil] >} }
+  it { assert_equal Create.(pass: true).inspect(:x), %{<Result:true [true] >} }
 end
 
 #---
@@ -97,8 +99,8 @@ class DocsGuardNamedTest < Minitest::Spec
   end
   #:name end
 
-  it { Create.(:current_user => nil   )[:"result.policy.user"].success?.must_equal false }
-  it { Create.(:current_user => Module)[:"result.policy.user"].success?.must_equal true }
+  it { assert_equal Create.(:current_user => nil   )[:"result.policy.user"].success?, false }
+  it { assert_equal Create.(:current_user => Module)[:"result.policy.user"].success?, true }
 
   it {
   #:name-result
@@ -117,7 +119,7 @@ class DocsGuardInjectionTest < Minitest::Spec
   end
   #:di-op end
 
-  it { Create.(:current_user => Module).inspect("").must_equal %{<Result:true [nil] >} }
+  it { assert_equal Create.(:current_user => Module).inspect(""), %{<Result:true [nil] >} }
   it {
     result =
   #:di-call
@@ -126,7 +128,7 @@ class DocsGuardInjectionTest < Minitest::Spec
     :"policy.default.eval"  => Trailblazer::Operation::Policy::Guard.build(->(options, **) { false })
   )
   #:di-call end
-    result.inspect("").must_equal %{<Result:false [nil] >} }
+    assert_equal result.inspect(""), %{<Result:false [nil] >} }
 end
 
 #---
@@ -137,7 +139,7 @@ class DocsGuardMissingKeywordTest < Minitest::Spec
   end
 
   it { assert_raises(ArgumentError) { Create.() } }
-  it { Create.(:current_user => Module).success?.must_equal true }
+  it { assert_equal Create.(:current_user => Module).success?, true }
 end
 
 #---
@@ -151,7 +153,7 @@ class DocsGuardPositionTest < Minitest::Spec
   end
   #:before end
 
-  it { Trailblazer::Developer.railway(Create).must_equal %{[>policy.default.eval,>model!]} }
+  it { assert_equal Trailblazer::Developer.railway(Create), %{[>policy.default.eval,>model!]} }
   it do
     #:before-pipe
       Trailblazer::Developer.railway(Create, style: :rows) #=>

data/test/docs/macro_test.rb

@@ -28,7 +28,7 @@ class DocsMacroTest < Minitest::Spec
   end
 =end
 
-  it { Trailblazer::Developer.railway(Create).must_equal %{[>my_policy.manager]} }
+  it { assert_equal Trailblazer::Developer.railway(Create), %{[>my_policy.manager]} }
 end