trailblazer-macro 2.1.9 → 2.1.10.beta1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 639ab06bc834f5258e404d9c87e1e53db434884225e6f6c222afcb9df9597154
-  data.tar.gz: b5f08c21b83529cd8a12fed2e6ef3e638a9db546b2d57d651f3a9f9adec8ff3c
+  metadata.gz: 4e07fee7d3fb35d6b830f020d3d3881be004a64ca3d6a82a9dce8ed314d732f5
+  data.tar.gz: e8a2f00963f34d5ac031e80df423700148110afd1f3ae7132837992de8542e5b
 SHA512:
-  metadata.gz: ebf4969c76b10be6b3e842376ebbb6bb5fd73bd7a3c8fe1f6c61ab1efb9e8d945b3bb13404fcf6cdbead3590deb5cf9aeaf0150a32209d14107e2019981732ed
-  data.tar.gz: 5d485adedac0da50b68f3528ddaf80329f9d33a06cd6768e7a7c1d430c4f7ff05bf5daafbf14eb174fd821bbb5d1108150bbb278fbc7eacb960c26fd8f058cca
+  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,9 @@
+# 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()`.

data/lib/trailblazer/macro/model.rb

@@ -1,55 +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 = nil, action = :new, find_by_key = :id, 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.
 
-    injections = { # defaulting as per `:inject` API.
-      :"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, inject: [:params, injections]} # pass-through {:params} if it's in ctx.
+      options = {task: task, id: id}.merge(injections)
 
-    options = options.merge(Linear::Output(:failure) => Linear::End(:not_found)) if not_found_terminus
+      options = options.merge(Activity::Railway.Output(:failure) => Activity::Railway.End(:not_found)) if not_found_terminus
 
-    options
-  end
-
-  class Model
-    def call(ctx, params: {}, **)
-      builder                 = Model::Builder.new
-      ctx[:model]         = model = builder.call(ctx, params)
-      ctx[:"result.model"] = result = Trailblazer::Operation::Result.new(!model.nil?, {})
-
-      result.success?
+      options
     end
 
-    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
+    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

@@ -9,24 +9,26 @@ module Trailblazer
              "Using the `Nested()` macro with operations and activities is deprecated. " \
              "Replace `Nested(#{callable})` with `Subprocess(#{callable})`."
 
-        return Nested.operation_class.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
 
@@ -45,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

@@ -33,11 +33,13 @@ module Trailblazer::Macro
       task = Eval.new(name: name, path: path)
 
       injections = {
-        # :"policy.default.eval"
-        path => ->(*) { condition }
+        Trailblazer::Activity::Railway.Inject() => {
+          # :"policy.default.eval"
+          path => ->(*) { condition }
+        }
       }
 
-      {task: task, id: path, inject: [injections]}
+      {task: task, id: path}.merge(injections)
     end
   end
 end

data/lib/trailblazer/macro/version.rb

@@ -1,7 +1,7 @@
 module Trailblazer
   module Version
     module Macro
-      VERSION = "2.1.9"
+      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/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/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

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.5.0", "< 0.6.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,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: trailblazer-macro
 version: !ruby/object:Gem::Version
-  version: 2.1.9
+  version: 2.1.10.beta1
 platform: ruby
 authors:
 - Nick Sutterer
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-12-13 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.5.0
+        version: 1.0.0.beta1
     - - "<"
       - !ruby/object:Gem::Version
-        version: 0.6.0
+        version: 1.1.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.5.0
+        version: 1.0.0.beta1
     - - "<"
       - !ruby/object:Gem::Version
-        version: 0.6.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
@@ -184,9 +184,9 @@ 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: