trailblazer-activity-dsl-linear 1.1.0 → 1.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 87302630d03df0e0e40ad7e7b9902744a1b9d7586e157018eab7652c6ad7276c
-  data.tar.gz: 10a821885b6a9e4228a0e04545d28689d28f4d3470f74b5f597f6d9bc1b4dd50
+  metadata.gz: a01800432c85f39dc5832995be63c19ca19e1783918556a763776656820945f7
+  data.tar.gz: 4a9115fcb36f0d15b3aea419745630abe28810741a64be16ea1ea025ea89a9fc
 SHA512:
-  metadata.gz: '08a071547063505433e4400c7f5e23c8203c72f125397bf71af8402050d728e1e5995fc71f5cd23a8da362c277bedb16a71e9d4f0b5f1c439d96eed82c4589fc'
-  data.tar.gz: 11e54d0175baa4fa338605faf1ac44ef1ef891a763890730c44119a239f11ea2f37497c80156bc2895a11b7b0a6ce58e9349e4a44e49f90c3dc48535ff179b57
+  metadata.gz: 97af4afb6eaf54e939345e17d28bf3b5894eb722c10c4f7757f8262d72456f0b5dabfffb04ba952fe4aa78d56528b4246b4813a9cf4d32d1c4a7689019d0c272
+  data.tar.gz: 9cdef15b9e400fef15fbcdb1252f32fd5b580e824af48d7caf9bfcb90a146fe5b6db2bdb489b7e6d92cb6bb198e6447076683bc8b3a9d2188fdb54844349202e

data/.github/workflows/ci.yml

@@ -1,6 +1,3 @@
-## This file is managed by Terraform.
-## Do not modify this file directly, as it may be overwritten.
-## Please open an issue instead.
 name: CI
 on: [push, pull_request]
 jobs:
@@ -8,12 +5,12 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        ruby: [2.7, '3.0', '3.1']
+        ruby: [2.5, 2.6, 2.7, '3.0', '3.1', '3.2', 'head', 'jruby']
     runs-on: ubuntu-latest
     steps:
     - uses: actions/checkout@v3
     - uses: ruby/setup-ruby@v1
       with:
         ruby-version: ${{ matrix.ruby }}
-        bundler-cache: true
+        bundler-cache: true # runs 'bundle install' and caches installed gems automatically
     - run: bundle exec rake

data/CHANGES.md

@@ -1,3 +1,79 @@
+# 1.2.1
+
+* Bugfix: `output_with_outer_ctx: :instance_method` no longer breaks.
+
+# 1.2.0
+
+## Introspect
+
+* As `Activity::Introspect::TaskMap` got removed, use `Activity::Introspect.Nodes(activity)` for introspecting. See https://trailblazer.to/2.1/docs/activity#activity-internals-introspection-api
+
+## Normalizer
+
+* Extract `normalizer/extension.rb` to implement `Extension() => myext`
+* Extract `normalizer/inherit.rb` to implement `inherit: true`.
+* Extract `normalizer/output_tuples.rb` which represents code for the Wiring API.
+* Connectors (`Track()`, `Id()` and `End()`) now contain the logic that returns the search builder. This used to sit in `#normalize_connections_from_dsl`.
+* What used to be the `"path.outputs"` step is now a separate, nested pipeline named `"activity.default_outputs"`. See https://trailblazer.to/2.1/docs/internals#internals-wiring-api-outputs-defaulting
+    Basically, The default step's outputs are set in that separate pipeline under `"activity.default_outputs"`.
+* Rename `"path.connections"` to `"path.step.add_success_connector"` for consistency.
+* Move `Railway::DSL::NormalizerForPass` to `Railway::DSL::Pass::Normalizer` (same for `Fail`).
+* Move `FastTrack::DSL::NormalizerForPass` to `FastTrack::DSL::Pass::Normalizer` (same for `Fail`).
+* Remove `"activity.normalize_outputs_from_dsl"` as this all happens in `#compile_wirings` now.
+
+## Various
+
+* Deprecate `Path(end_id:, end_task:)` options in favor of `Path(terminus: :semantic)`.
+* `FastTrack` outputs for non-`Subprocess()` are only added when `fast_track: true` is set.
+    As a result, this will throw an exception `No `pass_fast` output found for :find_model`.
+
+    ```ruby
+    step :find_model, Output(:pass_fast) # throws "no output" exception.
+    ```
+
+    and needs to be changed to
+
+    ```ruby
+    step :find_model,
+      fast_track: true,
+      Output(:pass_fast)
+    ```
+* Fixed a bug where `Subprocess(Path)` would accidentially add a `:failure` connection.
+    As a result, this doesn't work anymore
+
+    ```ruby
+    step Subprocess(Path), Output(:failure) => ...
+    ```
+* Allow inheriting of `:fail_fast`, `:pass_fast` and `:fast_track`.
+* The `:outputs` option for `#step` is now a private concept.  When passed explicitely to the normalizer (as it happens with `Subprocess()`) it's no longer extended or defaulted.
+* `Strategy.End()` now returns an `OutputTuples::End` instance. Use `Activity.End()` for the original behavior.
+* Removed the `:connections` option in favor of simply using output tuples for setting connections. We also don't inherit `:connections` anymore, but the output tuples.
+* Removed the `VariableMapping::Inherit` module as we can use generic inheritance logic.
+* Finally add the `Extension() => my_ext` option to painlessly add extensions. This means you don't have to manually merge `:extensions` anymore.
+* Extensions are now properly inherited (if `generic?` is false) using the universal inheritance mechanism.
+* `Strategy.invoke` now passes on keyword arguments, too.
+* A terminus step no longer maintains any wirings (as per `trailblazer-activity-0.16.0`), resulting in a terminus `Sequence` row as follows.
+
+    ```ruby
+    [
+      :success,
+      implementing::Success,
+      [], # no outputs anymore!
+      {id: "End.success", stop_event: true, semantic: :success}, # instead, {:semantic} is passed as a data option.
+    ]
+    ```
+* Remove `Search::Noop` as an empty wirings array in `Sequence` are allowed now.
+
+# 1.1.1
+
+* When using `step ..., inherit: true, replace: :find_model` you can now omit `:id`. The ID from
+  `:replace` is used automatically in that case.
+* Deprecate `:override` option for `#step`.
+* Simplify `inherit: [:variable_mapping]` by recording the `:in_filters` and `:out_filters` variables
+instead of the compiled pipelines. This fixes #61.
+* Introduce `#patch` to simplify modifying nested activities. Instead of `Subprocess(<activity>, patch: ...)` you can use
+  the dedicated DSL function.
+
 # 1.1.0
 
 * Use `trailblazer-activity` 0.15.0.

data/Gemfile

@@ -5,11 +5,14 @@ gemspec
 
 gem "minitest-line"
 
-# gem "trailblazer-developer", path: "../trailblazer-developer"
+# gem "trailblazer-developer",      path: "../trailblazer-developer"
 # gem "trailblazer-developer", github: "trailblazer/trailblazer-developer"
 # gem "trailblazer-declarative", path: "../trailblazer-declarative"
-# gem "trailblazer-activity", path: "../trailblazer-activity"
+# gem "trailblazer-activity",       path: "../trailblazer-activity"
 # gem "trailblazer-activity", github: "trailblazer/trailblazer-activity"
 # gem "trailblazer-activity", path: "../circuit"
-gem "benchmark-ips"
+
+# gem "benchmark-ips"
+# gem "stackprof"
+# gem "standard"
 # gem "trailblazer-core-utils", path: "../trailblazer-core-utils"

data/lib/trailblazer/activity/dsl/linear/feature/merge.rb

@@ -21,14 +21,14 @@ class Trailblazer::Activity
 
           _seq = Adds.apply_adds(
             old_seq,
-            new_seq.collect { |row| {insert: [Adds::Insert.method(:Prepend), end_id], row: row } }
+            new_seq.collect { |row| {insert: [Adds::Insert.method(:Prepend), end_id], row: row} }
           )
         end
 
         def self.strip_start_and_ends(seq, end_id:)
           cut_off_index = end_id.nil? ? seq.size : Adds::Insert.find_index(seq, end_id) # find the "first" end.
 
-          seq[1..cut_off_index-1]
+          seq[1..cut_off_index - 1]
         end
       end # Merge
     end

data/lib/trailblazer/activity/dsl/linear/feature/patch.rb

@@ -1,16 +1,11 @@
 class Trailblazer::Activity
   module DSL
     module Linear
-      def self.Patch(activity, instructions)
-        Patch.customize(activity, options: instructions)
-      end
-
       module Patch
-      # DISCUSS: we could make this a generic DSL option, not just for Subprocess().
         # Currently, this is called from the Subprocess() helper.
         def self.customize(activity, options:)
           options = options.is_a?(Proc) ?
-            { [] => options } : # hash-wrapping with empty path, for patching given activity itself
+            {[] => options} : # hash-wrapping with empty path, for patching given activity itself
             options
 
           options.each do |path, patch|
@@ -20,12 +15,12 @@ class Trailblazer::Activity
           activity
         end
 
-        def self.call(activity, path, customization)
+        def self.call(activity, path, customization, patched_activity: Class.new(activity))
           task_id, *path = path
 
           patch =
             if task_id
-              segment_activity = Introspect::TaskMap(activity).find_by_id(task_id).task
+              segment_activity = Introspect.Nodes(activity, id: task_id).task
               patched_segment_activity = call(segment_activity, path, customization)
 
               # Replace the patched subprocess.
@@ -34,10 +29,15 @@ class Trailblazer::Activity
               customization # apply the *actual* patch from the Subprocess() call.
             end
 
-          patched_activity = Class.new(activity)
           patched_activity.class_exec(&patch)
           patched_activity
         end
+
+        module DSL
+          def patch(*path, &block)
+            Patch.call(self, path, block, patched_activity: self)
+          end
+        end
       end # Patch
     end
   end

data/lib/trailblazer/activity/dsl/linear/feature/variable_mapping/dsl.rb

@@ -11,11 +11,9 @@ module Trailblazer
             module_function
 
             # Compute pipeline for In() and Inject().
-            # We allow to inject {:initial_input_pipeline} here in order to skip creating a new input pipeline and instead
-            # use the inherit one.
             def pipe_for_composable_input(in_filters: [], initial_input_pipeline: initial_input_pipeline_for(in_filters), **)
               in_filters  = DSL::Tuple.filters_from_options(in_filters)
-              pipeline    = add_filter_steps(initial_input_pipeline, in_filters)
+              _pipeline   = add_filter_steps(initial_input_pipeline, in_filters)
             end
 
             # initial pipleline depending on whether or not we got any In() filters.
@@ -25,7 +23,6 @@ module Trailblazer
               initial_input_pipeline(add_default_ctx: is_inject_only)
             end
 
-
             # Adds the default_ctx step as per option {:add_default_ctx}
             def initial_input_pipeline(add_default_ctx: false)
               # No In() or {:input}. Use default ctx, which is the original ctxx.
@@ -33,10 +30,10 @@ module Trailblazer
               default_ctx_row =
                 add_default_ctx ? Activity::TaskWrap::Pipeline.Row(*default_input_ctx_config) : nil
 
-              pipe = Activity::TaskWrap::Pipeline.new(
+              Activity::TaskWrap::Pipeline.new(
                 [
                   default_ctx_row,
-                  Activity::TaskWrap::Pipeline.Row("input.scope",     VariableMapping.method(:scope)), # last step
+                  Activity::TaskWrap::Pipeline.Row("input.scope", VariableMapping.method(:scope)), # last step
                 ].compact
               )
             end
@@ -45,7 +42,7 @@ module Trailblazer
               ["input.default_input", VariableMapping.method(:default_input_ctx)]
             end
 
-              # Handle {:input} and {:inject} option, the "old" interface.
+            # Handle {:input} and {:inject} option, the "old" interface.
             def add_steps_for_input_option(pipeline, input:)
               tuple         = DSL.In() # simulate {In() => input}
               input_filter  = DSL::Tuple.filters_from_options([[tuple, input]])
@@ -85,7 +82,7 @@ module Trailblazer
               Activity::Adds.apply_adds(pipeline, adds)
             end
 
-                      # Returns array of step rows ("sequence").
+            # Returns array of step rows ("sequence").
             # @param filters [Array] List of {Filter} objects
             def add_variables_steps_for_filters(filters, path_prefix:)
               filters.collect do |filter|
@@ -93,7 +90,6 @@ module Trailblazer
               end
             end
 
-
             # Keeps user's DSL configuration for a particular io-pipe step.
             # Implements the interface for the actual I/O code and is DSL code happening in the normalizer.
             # The actual I/O code expects {DSL::In} and {DSL::Out} objects to generate the two io-pipes.
@@ -102,7 +98,7 @@ module Trailblazer
             # This is also the reason why a lot of options computation such as {:with_outer_ctx} happens here and not in the IO code.
 
             class Tuple
-              def initialize(variable_name, add_variables_class, filters_builder, add_variables_class_for_callable=nil, insert_args: nil, **options)
+              def initialize(variable_name, add_variables_class, filters_builder, add_variables_class_for_callable = nil, insert_args: nil, **options)
                 @options =
                   {
                     variable_name:        variable_name,
@@ -121,7 +117,7 @@ module Trailblazer
               end
 
               def self.filters_from_options(tuples_to_user_filters)
-                tuples_to_user_filters.collect { |tuple, user_filter| tuple.(user_filter) }.flatten(1)
+                tuples_to_user_filters.flat_map { |tuple, user_filter| tuple.(user_filter) }
               end
 
               # @return [Filter] Filter instance that keeps {name} and {aggregate_step}.
@@ -161,14 +157,14 @@ module Trailblazer
                   end
 
                   # callable, producing a hash!
-
-                  return build_for_option(user_filter,
-                      name:                 Filter.name_for(type, user_filter.object_id, :add_variables),
-                      write_name:           nil,
-                      read_name:            nil,
-                      add_variables_class:  add_variables_class_for_callable, # for example, {AddVariables::Output}
-                      **options
-                    )
+                  build_for_option(
+                    user_filter,
+                    name:                 Filter.name_for(type, user_filter.object_id, :add_variables),
+                    write_name:           nil,
+                    read_name:            nil,
+                    add_variables_class:  add_variables_class_for_callable, # for example, {AddVariables::Output}
+                    **options
+                  )
                   # TODO: remove {add_variables_class_for_callable} and make everything SetVariable.
                 end # call
 
@@ -192,20 +188,21 @@ module Trailblazer
               class FiltersBuilder
                 def self.call(user_filter, with_outer_ctx:, **options)
                   if with_outer_ctx
-                    callable    = user_filter # FIXME: :instance_method, for fuck's sake.
-                    call_method = callable.respond_to?(:arity) ? callable : callable.method(:call)
+                    callable = Trailblazer::Option(user_filter) # FIXME: :instance_method
+                    arity = case user_filter
+                            when Symbol then nil
+                            when Proc then user_filter.arity
+                            else user_filter.method(:call).arity
+                            end
 
                     options =
                       # TODO: remove {if} and only leave {else}.
-                      if call_method.arity == 3
-                        index = caller_locations.find_index { |location| location.to_s =~ /recompile_activity_for/ }
-                        caller_location = caller_locations[index+2]
-
-                        Activity::Deprecate.warn caller_location,
+                      if arity == 3
+                        Activity::Deprecate.warn Linear::Deprecate.dsl_caller_location,
                           "The positional argument `outer_ctx` is deprecated, please use the `:outer_ctx` keyword argument.\n#{VariableMapping.deprecation_link}"
 
                         options.merge(
-                          filter:                           Trailblazer::Option(user_filter),
+                          filter:                           callable,
                           add_variables_class_for_callable: AddVariables::Output::WithOuterContext_Deprecated, # old positional arg
                         )
                       else
@@ -234,7 +231,6 @@ module Trailblazer
                 add_variables_class,
                 filter_builder,
                 add_variables_class_for_callable,
-
                 with_outer_ctx: with_outer_ctx,
               )
             end
@@ -292,7 +288,6 @@ module Trailblazer
                     )
                   end
 
-
                   # Build {SetVariable::Default}
                   # {user_filter} is one of the following
                   # :instance_method
@@ -349,7 +344,7 @@ module Trailblazer
               end
 
               def self.build_filters_for_hash(user_filter, **options)
-                return user_filter.collect do |from_name, to_name|
+                user_filter.collect do |from_name, to_name|
                   options = yield(options, from_name, to_name)
 
                   Filter.build_for_reading(
@@ -363,11 +358,10 @@ module Trailblazer
                 ary.collect { |name| [name, name] }.to_h
               end
 
-              def self.name_for(type, name, specifier=nil)
+              def self.name_for(type, name, specifier = nil)
                 [type, specifier].compact.join(".") + "{#{name}}"
               end
             end # Filter
-
           end # DSL
         end
       end

data/lib/trailblazer/activity/dsl/linear/feature/variable_mapping/runtime.rb

@@ -33,10 +33,10 @@ module Trailblazer
           #   output_ctx = @filter.(returned_ctx, [original_ctx, returned_flow_options], **original_circuit_options)
           # Returns {output_ctx} that is used after taskWrap finished.
           class Output < Input
-              def call(wrap_ctx, original_args)
-                returned_ctx, returned_flow_options = wrap_ctx[:return_args]  # this is the Context returned from {call}ing the wrapped user task.
-                original_ctx                        = wrap_ctx[@id]           # grab the original ctx from before which was set in the {:input} filter.
-                _, original_circuit_options         = original_args
+            def call(wrap_ctx, original_args)
+              returned_ctx, returned_flow_options = wrap_ctx[:return_args]  # this is the Context returned from {call}ing the wrapped user task.
+              original_ctx                        = wrap_ctx[@id]           # grab the original ctx from before which was set in the {:input} filter.
+              _, original_circuit_options         = original_args
 
               # let user compute the output.
               pipe_ctx, _     = @pipe.({original_ctx: original_ctx, returned_ctx: returned_ctx, aggregate: {}}, [[original_ctx, returned_flow_options], original_circuit_options])
@@ -97,8 +97,7 @@ module Trailblazer
 
           attr_reader :name # TODO: used when adding to pipeline, change to to_h
 
-          def call(wrap_ctx, original_args, filter=@filter)
-
+          def call(wrap_ctx, original_args, filter = @filter)
             wrap_ctx = self.class.set_variable_for_filter(filter, @write_name, wrap_ctx, original_args)
 
             return wrap_ctx, original_args
@@ -193,8 +192,7 @@ module Trailblazer
           end
         end # SetVariable
 
-
-  # AddVariables: I call something with an Option-interface and run the return value through merge_variables().
+        # AddVariables: I call something with an Option-interface and run the return value through merge_variables().
         # works on {:aggregate} by (usually) producing a hash fragment that is merged with the existing {:aggregate}
 
         # Add a hash of variables to aggregate after running a filter (which returns a hash!).

data/lib/trailblazer/activity/dsl/linear/feature/variable_mapping.rb

@@ -5,11 +5,10 @@ module Trailblazer
         # Normalizer-steps to implement {:input} and {:output}
         # Returns an Extension instance to be thrown into the `step` DSL arguments.
         def self.VariableMapping(input_id: "task_wrap.input", output_id: "task_wrap.output", **options)
-          input, output, normalizer_options, non_symbol_options = VariableMapping.merge_instructions_from_dsl(**options)
+          input, output = VariableMapping.merge_instructions_from_dsl(**options)
+          extension     = VariableMapping.Extension(input, output)
 
-          extension = VariableMapping.Extension(input, output)
-
-          return TaskWrap::Extension::WrapStatic.new(extension: extension), normalizer_options, non_symbol_options
+          TaskWrap::Extension::WrapStatic.new(extension: extension)
         end
 
         module VariableMapping
@@ -20,7 +19,7 @@ module Trailblazer
                 normalizer,
                 "activity.wirings",
                 {
-                   # In(), Out(), {:input}, Inject() feature
+                  # In(), Out(), {:input}, Inject() feature
                   "activity.convert_symbol_options"           => Linear::Normalizer.Task(VariableMapping::Normalizer.method(:convert_symbol_options)),
                   "activity.normalize_input_output_filters"   => Linear::Normalizer.Task(VariableMapping::Normalizer.method(:normalize_input_output_filters)),
                   "activity.input_output_dsl"                 => Linear::Normalizer.Task(VariableMapping::Normalizer.method(:input_output_dsl)),
@@ -60,7 +59,7 @@ module Trailblazer
                 inject.collect do |filter|
                   filter = filter.is_a?(Symbol) ? [filter] : filter
 
-                  dsl_options.merge!(VariableMapping::DSL.Inject()  => filter)
+                  dsl_options.merge!(VariableMapping::DSL.Inject() => filter)
                 end
               end
 
@@ -72,43 +71,44 @@ module Trailblazer
 
             # Process {In() => [:model], Inject() => [:current_user], Out() => [:model]}
             def self.normalize_input_output_filters(ctx, non_symbol_options:, input_output_inject_options: [], **)
-              in_exts     = non_symbol_options.find_all { |k,v| k.is_a?(VariableMapping::DSL::In) || k.is_a?(VariableMapping::DSL::Inject) }
-              output_exts = non_symbol_options.find_all { |k,v| k.is_a?(VariableMapping::DSL::Out) }
+              in_exts     = non_symbol_options.find_all { |k, v| k.is_a?(VariableMapping::DSL::In) || k.is_a?(VariableMapping::DSL::Inject) }
+              output_exts = non_symbol_options.find_all { |k, v| k.is_a?(VariableMapping::DSL::Out) }
 
               return unless in_exts.any? || output_exts.any?
 
               deprecate_input_output_inject_option(input_output_inject_options, in_exts, output_exts)
 
-              ctx[:in_filters]     = in_exts
-              ctx[:out_filters]    = output_exts
+              ctx[:in_filters]  = in_exts
+              ctx[:out_filters] = output_exts
             end
 
-            def self.input_output_dsl(ctx, extensions: [], **options)
+            def self.input_output_dsl(ctx, non_symbol_options:, in_filters: nil, out_filters: nil, **options)
               # no :input/:output/:inject/Input()/Output() passed.
-              return if (options.keys & [:in_filters, :output_filters]).empty?
+              return unless in_filters || out_filters
+
+              extension = Linear.VariableMapping(in_filters: in_filters, out_filters: out_filters, **options)
+
+              record = Linear::Normalizer::Inherit.Record((in_filters + out_filters).to_h, type: :variable_mapping)
 
-              extension, normalizer_options, non_symbol_options = Linear.VariableMapping(**options)
+              non_symbol_options = non_symbol_options.merge(record)
+              non_symbol_options = non_symbol_options.merge(Linear::Strategy.Extension(is_generic: true)  => extension)
 
-              ctx[:extensions] = extensions + [extension] # FIXME: allow {Extension() => extension}
-              ctx.merge!(**normalizer_options) # DISCUSS: is there another way of merging variables into ctx?
-              ctx[:non_symbol_options].merge!(non_symbol_options)
+              ctx.merge!(
+                non_symbol_options: non_symbol_options
+              )
             end
 
             # TODO: remove for TRB 2.2.
             def self.deprecate_input_output_inject_option(input_output_inject_options, *composable_options)
               return unless input_output_inject_options.any?
-              options, dsl_options = input_output_inject_options
+              options, _dsl_options = input_output_inject_options
 
-              deprecated_options_count = options.find_all { |(name, option)| option }.count + (options[:inject] ? options[:inject].count-1 : 0)
+              deprecated_options_count = options.find_all { |(name, option)| option }.count + (options[:inject] ? options[:inject].count - 1 : 0)
               composable_options_count = composable_options.collect { |options| options.size }.sum
 
               return if composable_options_count == deprecated_options_count
 
-              # for deprecation warnings, guess the location if {:input} from the stack.
-              caller_index    = caller_locations.find_index { |location| location.to_s =~ /recompile_activity_for/ }
-              caller_location = caller_index ? caller_locations[caller_index+2] : caller_locations[0]
-
-              Activity::Deprecate.warn caller_location, %{You are mixing #{options.inspect} with In(), Out() and Inject().\n#{VariableMapping.deprecation_link}}
+              Activity::Deprecate.warn Linear::Deprecate.dsl_caller_location, %(You are mixing #{options.inspect} with In(), Out() and Inject().\n#{VariableMapping.deprecation_link})
             end
           end
 
@@ -129,21 +129,11 @@ module Trailblazer
             output_pipeline = DSL.pipe_for_composable_output(**options)
             output          = Pipe::Output.new(output_pipeline)
 
-            return input, output,
-              # normalizer_options:
-              {
-                variable_mapping_pipelines: [pipeline, output_pipeline],
-              },
-              # non_symbol_options:
-              {
-                Linear::Strategy.DataVariable() => :variable_mapping_pipelines # we want to store {:variable_mapping_pipelines} in {Row.data} for later reference.
-              }
-              # DISCUSS: should we remember the pure pipelines or get it from the compiled extension?
-              # store pipe in the extension (via TW::Extension.data)?
+            return input, output
           end
 
           def deprecation_link
-            %{Please refer to https://trailblazer.to/2.1/docs/activity.html#activity-variable-mapping-deprecation-notes and have a nice day.}
+            %(Please refer to https://trailblazer.to/2.1/docs/activity.html#activity-variable-mapping-deprecation-notes and have a nice day.)
           end
         end # VariableMapping
       end

data/lib/trailblazer/activity/dsl/linear/helper/path.rb

@@ -3,7 +3,7 @@ module Trailblazer
     module DSL
       module Linear
         module Helper
-          # Normalizer logic for {Path() do end}.
+          # Normalizer logic for {Path() do ... end}.
           #
           # TODO: it would be cool to be able to connect an (empty) path to specific termini,
           #       this would work if we could add multiple magnetic_to.
@@ -11,6 +11,7 @@ module Trailblazer
             # Normalizer steps to handle Path() macro.
             module Normalizer
               module_function
+
               # Replace a block-expecting {PathBranch} instance with another one that's holding
               # the global {:block} from {#step ... do end}.
               def forward_block_for_path_branch(ctx, options:, normalizer_options:, library_options:, **)
@@ -20,12 +21,12 @@ module Trailblazer
                 return unless block
 
                 output, path_branch =
-                  non_symbol_options.find { |output, cfg| cfg.kind_of?(Linear::PathBranch) }
+                  non_symbol_options.find { |output, cfg| cfg.is_a?(Linear::PathBranch) }
 
                 path_branch_with_block = Linear::PathBranch.new(
-                  normalizer_options.
-                    merge(path_branch.options).
-                    merge(block: block)
+                  normalizer_options
+                    .merge(path_branch.options)
+                    .merge(block: block)
                 )
 
                 ctx[:options] = ctx[:options].merge(non_symbol_options: non_symbol_options.merge(output => path_branch_with_block))
@@ -35,10 +36,10 @@ module Trailblazer
               # The {Track} instance contains all additional {adds} steps and
               # is picked up in {Normalizer.normalize_connections_from_dsl}.
               def convert_paths_to_tracks(ctx, non_symbol_options:, block: false, **)
-                new_tracks = non_symbol_options.
-                  find_all { |output, cfg| cfg.kind_of?(Linear::PathBranch) }.
-                  collect {  |output, cfg| [output, Path.convert_path_to_track(block: ctx[:block], **cfg.options)]  }.
-                  to_h
+                new_tracks = non_symbol_options
+                  .find_all { |output, cfg| cfg.is_a?(Linear::PathBranch) }
+                  .collect {  |output, cfg| [output, Path.convert_path_to_track(block: block, **cfg.options)]  }
+                  .to_h
 
                 ctx[:non_symbol_options] = non_symbol_options.merge(new_tracks)
               end
@@ -46,7 +47,27 @@ module Trailblazer
 
             module_function
 
-            def convert_path_to_track(track_color: "track_#{rand}", connect_to: nil, before: false, block: nil, **options)
+            def convert_path_to_track(track_color: "track_#{rand}", connect_to: nil, before: false, block: nil, terminus: nil, **options)
+              options =
+                if end_task = options[:end_task] # TODO: remove in 2.0.
+                  Activity::Deprecate.warn Linear::Deprecate.dsl_caller_location,
+                    %(Using `:end_task` and `:end_id` in Path() is deprecated, use `:terminus` instead. Please refer to https://trailblazer.to/2.1/docs/activity.html#activity-wiring-api-path-end_task-end_id-deprecation)
+
+                  options.merge(
+                    end_task: Activity.End(end_task.to_h[:semantic]),
+                    end_id:   options[:end_id]
+                  )
+                elsif connect_to
+                  {}
+                elsif terminus
+                  options.merge(
+                    end_task: Activity.End(terminus),
+                    end_id:   "End.#{terminus}"
+                  )
+                else # Path() with End() inside block.
+                  {}
+                end
+
               # DISCUSS:  if anyone overrides `#step` in the "outer" activity, this won't be applied inside the branch.
 
               # DISCUSS: use Path::Sequencer::Builder here instead?
@@ -54,7 +75,7 @@ module Trailblazer
 
               seq = path.to_h[:sequence]
               # Strip default ends `Start.default` and `End.success` (if present).
-              seq = seq[1..-1].reject{ |row| row[3][:stop_event] && row.id == 'End.success' }
+              seq = seq[1..-1].reject { |row| row[3][:stop_event] && row.id == "End.success" }
 
               if connect_to
                 seq = connect_for_sequence(seq, connect_to: connect_to)
@@ -69,7 +90,7 @@ module Trailblazer
                 insert_method = options[:stop_event] ? Activity::Adds::Insert.method(:Append) : Activity::Adds::Insert.method(:Prepend)
 
                 insert_target = "End.success" # insert before/after
-                insert_target = before if before && connect_to.instance_of?(Trailblazer::Activity::DSL::Linear::Track) # FIXME: this is a bit hacky, of course!
+                insert_target = before if before && connect_to.instance_of?(Linear::Normalizer::OutputTuples::Track) # FIXME: this is a bit hacky, of course!
 
                 {
                   row:    row,
@@ -78,7 +99,7 @@ module Trailblazer
               end
 
               # Connect the Output() => Track(path_track)
-              return Linear::Track.new(track_color, adds, {})
+              Linear::Normalizer::OutputTuples::Track.new(track_color, adds, {})
             end
 
             # Connect last row of the {sequence} to the given step via its {Id}
@@ -87,16 +108,14 @@ module Trailblazer
               output, _ = sequence[-1][2][0].(sequence, sequence[-1]) # FIXME: the Forward() proc contains the row's Output, and the only current way to retrieve it is calling the search strategy. It should be Forward#to_h
 
               # searches = [Search.ById(output, connect_to.value)]
-              searches = [Sequence::Search.ById(output, connect_to.value)] if connect_to.instance_of?(Trailblazer::Activity::DSL::Linear::Id)
-              searches = [Sequence::Search.Forward(output, connect_to.color)] if connect_to.instance_of?(Trailblazer::Activity::DSL::Linear::Track) # FIXME: use existing mapping logic!
+              searches = [Sequence::Search.ById(output, connect_to.value)] if connect_to.instance_of?(Linear::Normalizer::OutputTuples::Id)
+              searches = [Sequence::Search.Forward(output, connect_to.color)] if connect_to.instance_of?(Linear::Normalizer::OutputTuples::Track) # FIXME: use existing mapping logic!
 
               row = sequence[-1]
               row = row[0..1] + [searches] + [row[3]] # FIXME: not mutating an array is so hard: we only want to replace the "searches" element, index 2
               row = Sequence::Row[*row]
 
-              sequence = sequence[0..-2] + [row]
-
-              sequence
+              sequence[0..-2] + [row]
             end
           end # Path
         end