trailblazer-activity-dsl-linear 0.5.0 → 1.0.0.beta1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6185e8d95445bb10e611433a6885be07ec85524cdb5d45e1aed6449610391dd1
-  data.tar.gz: e0af2bf5eba1bbb381c35675c3352ba99b5a3598964e9deffeec75d8e6b3be58
+  metadata.gz: 40f3c629e47f86039e0028f0e82f78a51f9b4d7d9e6c953a3605510b1241c050
+  data.tar.gz: 54a79c00d4a4505c0da36dcffb209f1fdf6a5c438156620c665443d481039f7d
 SHA512:
-  metadata.gz: 3ae89d32dddf81784df0abb2d103c3672125c80f6637e5cae76a3a460addb75e7707352a43643d8359273cb7c2e6c5e96636e19c714adebe5da657cd74d5c73e
-  data.tar.gz: c9f56bcb32fd1e1ba4adb7e8b39af43093d96a0eadb9ff21cbe35a2207a4c7b70728ee1eda7de00af1bf0972afbb51744143ff6f3d05595c6457c209f31b38c4
+  metadata.gz: c4c2d3df3fff7dbae401d840c1a4efca1397be7a7839b2d89b05300bd17f4b41df0f86c32c19ea98c2a61e8d1a045278592041605c06c7e4a46797e8f5bc97b7
+  data.tar.gz: daa3b6f02156a479bda2b6359583be835a6b908415a388714c6e3d17004e6dff3f8682619e83ace151259deca834744de7521d30916626df05a9e207b2705e7e

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', head, jruby]
     runs-on: ubuntu-latest
     steps:
     - uses: actions/checkout@v2

data/CHANGES.md

@@ -1,3 +1,55 @@
+# 1.0.0
+
+## Additions
+
+* Introduce composable input/output filters with `In()`, `Out()` and `Inject()`. # FIXME: add link
+* We no longer store arbitrary variables from `#step` calls in the sequence row's `data` field.
+  Use the `DataVariable` helper to mark variables for storage in `data`.
+
+  ```ruby
+  step :find_model,
+    model_class: Song,
+    Trailblazer::Activity::DSL::Linear::Helper.DataVariable() => :model_class
+  ```
+* Add `Normalizer.extend!` to add steps to a particular normalizer. # FIXME: add link
+* Add `Strategy.terminus` to add termini. # FIXME: add link
+* The `Sequence` instance is now readable via `#to_h`: `Strategy.to_h[:sequence]`.
+* In Normalizer, the `path.wirings` step is now named `activity.wirings`.
+
+## Design
+
+  * DSL logic: move as much as possible into the normalizer as it's much easier to understand and follow (and debug).
+  * Each DSL method now directly invokes a normalizer pipeline that processes the user options and produces an ADDS structure.
+* We now need `Sequence::Row` instances in `Sequence` to adhere to the Adds specification.
+* Rename `Linear::State` to `Linear::Sequence::Builder`. This is now a stateless function, only.
+  Sequence::Builder.()
+* @state ?
+* Remove `Strategy@activity` instance variable and move it to `@state[:activity]`.
+* Much better file structuring.
+
+## Internals
+
+* Use `Trailblazer::Declarative::State` to maintain sequence and other fields. This makes inheritance consistent.
+* Make `Strategy` a class. It makes constant management much simpler to understand.
+* `Linear.end_id` now accepts keyword arguments (mainly, `:semantic`).
+* `Strategy.apply_step_on_state!` is now an immutable `Sequence::Builder.update_sequence_for`.
+* The `Railway.Path()` helper returns a `DSL::PathBranch` non-symbol that is then picked up and processed by the normalizer (exactly how we do it with `In()`, `Track()` etc.). Branching implementation is handled in `helper/path.rb`.
+* Remove `State.update_options`. Use `@state.update!`.
+* Remove `Helper.normalize`.
+* Remove `Linear::DSL.insert_task`. The canonical way to add steps is using the ADDS interface going through a normalizer.
+  That's why there's a normalizer for `end` (or "terminus") now for consistency.
+* Remove `Helper::ClassMethods`, `Helper` is now the namespace to mix in your own functions (and ours, like `Output()`).
+* Introduce `Helper::Constants` for namespaced macros such as `Policy::Pundit()`.
+
+## Renaming
+
+* Rename `Linear::State::Normalizer` to `Linear::Normalizer::Normalizers` as it represents a container for normalizers.
+* Move `Linear::Insert` to `Activity::Adds::Insert` in the `trailblazer-activity` gem.
+* Move `Linear::Search` to `Linear::Sequence::Search` and `Linear::Compiler` to `Linear::Sequence::Compiler`.
+* `TaskWrap::Pipeline.prepend` is now `Linear::Normalizer.prepend_to`. To use the `:replace` option you can use `Linear::Normalizer.replace`.
+* Move `Sequence::IndexError` to `Activity::Adds::IndexError` in the `trailblazer-activity` gem. Remove `IndexError#step_id`.
+* Move DSL structures like `OutputSemantic` to `Linear` namespace.
+
 # 0.5.0
 
 * Introduce `:inject` option to pass-through injected variables and to default input variables.

data/Gemfile

@@ -8,6 +8,8 @@ gem "minitest-line"
 gem "rubocop", require: false
 
 # 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", github: "trailblazer/trailblazer-activity"
+# gem "trailblazer-activity", github: "trailblazer/trailblazer-activity"
 # gem "trailblazer-activity", path: "../circuit"

data/README.md

@@ -1,25 +1,24 @@
 # Activity-DSL-Linear
 
-The `activity-dsl-linear` gem brings:
-- [Path](https://trailblazer.to/2.1/docs/activity.html#activity-strategy-path)
-- [Railway](https://trailblazer.to/2.1/docs/activity.html#activity-strategy-railway)
-- [Fasttrack](https://trailblazer.to/2.1/docs/activity.html#activity-strategy-fasttrack)
-  
-DSLs strategies for buildig activities. It is build around [`activity`](https://github.com/trailblazer/trailblazer-activity) gem.
+The `trailblazer-activity-dsl-linear` gem brings the popular `step` DSL around the [`activity`](https://github.com/trailblazer/trailblazer-activity) gem. It allows to create classes that you might mostly know as _operations_ - service objects that execute your business logic in a certain order, depending on how you harness the `step` DSL.
 
 Please find the [full documentation on the Trailblazer website](https://trailblazer.to/2.1/docs/activity.html#activity-strategy).
 
 ## Example
 
-The `activity-dsl-linear` gem provides three default patterns to model processes: `Path`, `Railway` and `FastTrack`. Here's an example of what a railway activity could look like, along with some more complex connections (you can read more about Railway strategy in the [docs](https://trailblazer.to/2.1/docs/activity.html#activity-strategy-railway)).
+The `activity-dsl-linear` gem provides three default patterns to model activities: `Path`, `Railway` and `FastTrack`. Here's an example of what a railway activity could look like, along with some more complex connections (you can read more about Railway strategy in the [docs](https://trailblazer.to/2.1/docs/activity.html#activity-strategy-railway)).
 
 ```ruby
-require "trailblazer-activity"
 require "trailblazer-activity-dsl-linear"
 
 class Memo::Update < Trailblazer::Activity::Railway
-  # here goes your business logic
-  #
+  # Use the DSL to describe the layout of the activity.
+  step :find_model
+  step :validate, Output(:failure) => End(:validation_error)
+  step :save
+  fail :log_error
+
+  # Here comes your business logic.
   def find_model(ctx, id:, **)
     ctx[:model] = Memo.find_by(id: id)
   end
@@ -37,13 +36,6 @@ class Memo::Update < Trailblazer::Activity::Railway
   def log_error(ctx, params:, **)
     ctx[:log] = "Some idiot wrote #{params.inspect}"
   end
-
-  # here comes the DSL describing the layout of the activity
-  #
-  step :find_model
-  step :validate, Output(:failure) => End(:validation_error)
-  step :save
-  fail :log_error
 end
 ```
 

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

@@ -0,0 +1,36 @@
+class Trailblazer::Activity
+  module DSL
+    module Linear
+      module Merge
+        # Class methods for {Strategy}.
+        module DSL
+          def merge!(activity)
+            old_seq = to_h[:sequence]
+            new_seq = activity.to_h[:sequence]
+
+            seq = Merge.call(old_seq, new_seq, end_id: "End.success")
+
+            # Update the DSL's sequence, then recompile the actual activity.
+            recompile!(seq)
+          end
+        end
+
+        # Compile-time logic to merge two activities.
+        def self.call(old_seq, new_seq, end_id: "End.success") # DISCUSS: also Insert
+          new_seq = strip_start_and_ends(new_seq, end_id: end_id)
+
+          _seq = Adds.apply_adds(
+            old_seq,
+            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]
+        end
+      end # Merge
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+class Trailblazer::Activity
+  module DSL
+    module Linear
+      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
+
+          options.each do |path, patch|
+            activity = call(activity, path, patch) # TODO: test if multiple patches works!
+          end
+
+          activity
+        end
+
+        def self.call(activity, path, customization)
+          task_id, *path = path
+
+          patch =
+            if task_id
+              segment_activity = Introspect::Graph(activity).find(task_id).task
+              patched_segment_activity = call(segment_activity, path, customization)
+
+              # Replace the patched subprocess.
+              -> { step Subprocess(patched_segment_activity), inherit: true, replace: task_id, id: task_id }
+            else
+              customization # apply the *actual* patch from the Subprocess() call.
+            end
+
+          patched_activity = Class.new(activity)
+          patched_activity.class_exec(&patch)
+          patched_activity
+        end
+      end # Patch
+    end
+  end
+end

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

@@ -0,0 +1,281 @@
+module Trailblazer
+  class Activity
+    module DSL
+      module Linear
+        module VariableMapping
+          # Code invoked through the normalizer, building runtime structures.
+          # Naming
+          #   Option: Tuple => user filter
+          #   Tuple: #<In ...>
+          module DSL
+            module_function
+
+            # Compute pipeline for {:input} option.
+            def pipe_for_mono_input(input: [], inject: [], in_filters: [], output: [], **)
+              has_input              = Array(input).any?
+              has_mono_options       = has_input || Array(inject).any? || Array(output).any? # :input, :inject and :output are "mono options".
+              has_composable_options = in_filters.any? # DISCUSS: why are we not testing Inject()?
+
+              if has_mono_options && has_composable_options
+                warn "[Trailblazer] You are mixing `:input` and `In() => ...`. `In()` and Inject () options are ignored and `:input` wins: #{input} #{inject} #{output} <> #{in_filters} / "
+              end
+
+              pipeline = initial_input_pipeline(add_default_ctx: !has_input)
+              pipeline = add_steps_for_input_option(pipeline, input: input)
+              pipeline = add_steps_for_inject_option(pipeline, inject: inject)
+
+              return pipeline, has_mono_options, has_composable_options
+            end
+
+            # 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: [], inject_filters: [], initial_input_pipeline: initial_input_pipeline_for(in_filters), **)
+              inject_filters = DSL::Inject.filters_for_injects(inject_filters) # {Inject() => ...} the pure user input gets translated into AddVariable aggregate steps.
+              in_filters     = DSL::Tuple.filters_from_options(in_filters)
+
+              # With only injections defined, we do not filter out anything, we use the original ctx
+              # and _add_ defaulting for injected variables.
+              pipeline = add_filter_steps(initial_input_pipeline, in_filters)
+              pipeline = add_filter_steps(pipeline, inject_filters)
+            end
+
+            # initial pipleline depending on whether or not we got any In() filters.
+            def initial_input_pipeline_for(in_filters)
+              is_inject_only = Array(in_filters).empty?
+
+              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.
+              # When using Inject without In/:input, we also need a {default_input} ctx.
+              default_ctx_row =
+                add_default_ctx ? Activity::TaskWrap::Pipeline.Row(*default_input_ctx_config) : nil
+
+              pipe = Activity::TaskWrap::Pipeline.new(
+                [
+                  Activity::TaskWrap::Pipeline.Row("input.init_hash", VariableMapping.method(:initial_aggregate)), # very first step
+                  default_ctx_row,
+                  Activity::TaskWrap::Pipeline.Row("input.scope",     VariableMapping.method(:scope)), # last step
+                ].compact
+              )
+            end
+
+            def default_input_ctx_config # almost a Row.
+              ["input.default_input", VariableMapping.method(:default_input_ctx)]
+            end
+
+              # Handle {:input} and {:inject} option, the "old" interface.
+            def add_steps_for_input_option(pipeline, input:)
+              tuple         = DSL.In(name: ":input") # simulate {In() => input}
+              input_filter  = DSL::Tuple.filters_from_options([[tuple, input]])
+
+              add_filter_steps(pipeline, input_filter)
+            end
+
+
+            def pipe_for_mono_output(output_with_outer_ctx: false, output: [], out_filters: [], **)
+              # No Out(), no {:output} will result in a default_output_ctx step.
+              has_output             = Array(output).any?
+              has_mono_options       = has_output
+              has_composable_options = Array(out_filters).any?
+
+              if has_mono_options && has_composable_options
+                warn "[Trailblazer] You are mixing `:output` and `Out() => ...`. `Out()` options are ignored and `:output` wins."
+              end
+
+              pipeline = initial_output_pipeline(add_default_ctx: !has_output)
+              pipeline = add_steps_for_output_option(pipeline, output: output, output_with_outer_ctx: output_with_outer_ctx)
+
+              return pipeline, has_mono_options, has_composable_options
+            end
+
+            def add_steps_for_output_option(pipeline, output:, output_with_outer_ctx:)
+              tuple         = DSL.Out(name: ":output", with_outer_ctx: output_with_outer_ctx) # simulate {Out() => output}
+              output_filter = DSL::Tuple.filters_from_options([[tuple, output]])
+
+              add_filter_steps(pipeline, output_filter, prepend_to: "output.merge_with_original")
+            end
+
+            def pipe_for_composable_output(out_filters: [], initial_output_pipeline: initial_output_pipeline(add_default_ctx: Array(out_filters).empty?), **)
+              out_filters = DSL::Tuple.filters_from_options(out_filters)
+
+              add_filter_steps(initial_output_pipeline, out_filters, prepend_to: "output.merge_with_original")
+            end
+
+            def initial_output_pipeline(add_default_ctx: false)
+              default_ctx_row =
+                add_default_ctx ? Activity::TaskWrap::Pipeline.Row(*default_output_ctx_config) : nil
+
+              Activity::TaskWrap::Pipeline.new(
+                [
+                  Activity::TaskWrap::Pipeline.Row("output.init_hash", VariableMapping.method(:initial_aggregate)), # very first step
+                  default_ctx_row,
+                  Activity::TaskWrap::Pipeline.Row("output.merge_with_original", VariableMapping.method(:merge_with_original)), # last step
+                ].compact
+              )
+            end
+
+            def default_output_ctx_config # almost a Row.
+              ["output.default_output", VariableMapping.method(:default_output_ctx)]
+            end
+
+            def add_steps_for_inject_option(pipeline, inject:)
+              injects = inject.collect { |name| name.is_a?(Symbol) ? [DSL.Inject(), [name]] : [DSL.Inject(), name] }
+
+              tuples  = DSL::Inject.filters_for_injects(injects) # DISCUSS: should we add passthrough/defaulting here at Inject()-time?
+
+              add_filter_steps(pipeline, tuples)
+            end
+
+            def add_filter_steps(pipeline, rows, prepend_to: "input.scope") # FIXME: do we need all this?
+              rows = add_variables_steps_for_filters(rows)
+
+              adds = Activity::Adds::FriendlyInterface.adds_for(
+                rows.collect { |row| [row[1], id: row[0], prepend: prepend_to] }
+              )
+
+              Activity::Adds.apply_adds(pipeline, adds)
+            end
+
+                      # Returns array of step rows ("sequence").
+            # @param filters [Array] List of {Filter} objects
+            def add_variables_steps_for_filters(filters) # FIXME: allow output too!
+              filters.collect do |filter|
+                ["input.add_variables.#{filter.name}", filter.aggregate_step] # FIXME: config name sucks, of course, if we want to allow inserting etc.
+              end
+            end
+
+
+          # Filter code
+            # Converting user options to callable filters.
+
+            # @param [Array, Hash, Proc] User option coming from the DSL, like {[:model]}
+            #
+            # Returns a "filter interface" callable that's invoked in {AddVariables}:
+            #   filter.(new_ctx, ..., keyword_arguments: new_ctx.to_hash, **circuit_options)
+            def self.build_filter(user_filter)
+              Trailblazer::Option(filter_for(user_filter))
+            end
+
+            # Convert a user option such as {[:model]} to a filter.
+            #
+            # Returns a filter proc to be called in an Option.
+            # @private
+            def self.filter_for(filter)
+              if filter.is_a?(::Array) || filter.is_a?(::Hash)
+                filter_from_dsl(filter)
+              else
+                filter
+              end
+            end
+
+            # The returned filter compiles a new hash for Scoped/Unscoped that only contains
+            # the desired i/o variables.
+            #
+            # Filter expects a "filter interface" {(ctx, **)}.
+            def self.filter_from_dsl(map)
+              hsh = DSL.hash_for(map)
+
+              ->(incoming_ctx, **kwargs) { Hash[hsh.collect { |from_name, to_name| [to_name, incoming_ctx[from_name]] }] }
+            end
+
+            def self.hash_for(ary)
+              return ary if ary.instance_of?(::Hash)
+              Hash[ary.collect { |name| [name, name] }]
+            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.
+            #
+            # If a user needs to inject their own private iop step they can create this data structure with desired values here.
+            # 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 < Struct.new(:name, :add_variables_class, :filter_builder, :insert_args)
+              def self.filters_from_options(tuples_to_user_filters)
+                tuples_to_user_filters.collect { |tuple, user_filter| tuple.(user_filter) }
+              end
+
+
+              # @return [Filter] Filter instance that keeps {name} and {aggregate_step}.
+              def call(user_filter)
+                filter         = filter_builder.(user_filter)
+                aggregate_step = add_variables_class.new(filter, user_filter)
+
+                VariableMapping::Filter.new(aggregate_step, filter, name, add_variables_class)
+              end
+            end # TODO: implement {:insert_args}
+
+            # In, Out and Inject are objects instantiated when using the DSL, for instance {In() => [:model]}.
+            class In < Tuple; end
+            class Out < Tuple; end
+
+            def self.In(name: rand, add_variables_class: AddVariables, filter_builder: method(:build_filter))
+              In.new(name, add_variables_class, filter_builder)
+            end
+
+            # Builder for a DSL Output() object.
+            def self.Out(name: rand, add_variables_class: AddVariables::Output, with_outer_ctx: false, delete: false, filter_builder: method(:build_filter), read_from_aggregate: false)
+              add_variables_class = AddVariables::Output::WithOuterContext  if with_outer_ctx
+              add_variables_class = AddVariables::Output::Delete            if delete
+              filter_builder      = ->(user_filter) { user_filter }         if delete
+              add_variables_class = AddVariables::ReadFromAggregate         if read_from_aggregate
+
+              Out.new(name, add_variables_class, filter_builder)
+            end
+
+            def self.Inject()
+              Inject.new
+            end
+
+            # This class is supposed to hold configuration options for Inject().
+            class Inject
+            # Translate the raw input of the user to {In} tuples
+              # @return Array of VariableMapping::Filter
+              def self.filters_for_injects(injects)
+                injects.collect do |inject, user_filter| # iterate all {Inject() => user_filter} calls
+                  DSL::Inject.compute_filters_for_inject(inject, user_filter)
+                end.flatten(1)
+              end
+
+              # Compute {In} tuples from the user's DSL input.
+              # We simply use AddVariables but use our own {inject_filter} which checks if the particular
+              # variable is already present in the incoming ctx.
+              def self.compute_filters_for_inject(inject, user_filter) # {user_filter} either [:current_user, :model] or {model: ->{}}
+                return filters_for_array(inject, user_filter) if user_filter.is_a?(Array)
+                filters_for_hash_of_callables(inject, user_filter)
+              end
+
+              # [:model, :current_user]
+              def self.filters_for_array(inject, user_filter)
+                user_filter.collect do |name|
+                  inject_filter = ->(original_ctx, **) { original_ctx.key?(name) ? {name => original_ctx[name]} : {} } # FIXME: make me an {Inject::} method.
+
+                  filter_for(inject, inject_filter, name, "passthrough")
+                end
+              end
+
+              # {model: ->(*) { snippet }}
+              def self.filters_for_hash_of_callables(inject, user_filter)
+                user_filter.collect do |name, defaulting_filter|
+                  inject_filter = ->(original_ctx, **kws) { original_ctx.key?(name) ? {name => original_ctx[name]} : {name => defaulting_filter.(original_ctx, **kws)} }
+
+                  filter_for(inject, inject_filter, name, "defaulting_callable")
+                end
+              end
+
+              def self.filter_for(inject, inject_filter, name, type)
+                DSL.In(name: "inject.#{type}.#{name.inspect}", add_variables_class: AddVariables).(inject_filter)
+              end
+            end
+
+          end # DSL
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+module Trailblazer
+  class Activity
+    module DSL
+      module Linear
+        module VariableMapping
+          # Implements the {inherit: [:variable_mapping]} feature.
+          module Inherit
+            def self.extended(strategy) # FIXME: who implements {extend!}
+              Linear::Normalizer.extend!(strategy, :step) do |normalizer|
+                Linear::Normalizer.prepend_to(
+                  normalizer,
+                  "activity.normalize_input_output_filters",
+                  {
+                    "variable_mapping.inherit_option" => Linear::Normalizer.Task(VariableMapping::Inherit::Normalizer.method(:inherit_option)),
+                  }
+                )
+              end
+            end
+
+            module Normalizer
+              # Inheriting the original I/O happens by grabbing the variable_mapping_pipelines
+              # from the original sequence and pass it on in the normalizer.
+              # It will eventually get processed by {VariableMapping#pipe_for_composable_input} etc.
+              def self.inherit_option(ctx, inherit: [], sequence:, id:, **)
+                return unless inherit.include?(:variable_mapping)
+
+                inherited_input_pipeline, inherited_output_pipeline = Linear::Normalizer::InheritOption.find_row(sequence, id).data[:variable_mapping_pipelines]
+
+                ctx[:initial_input_pipeline]  = inherited_input_pipeline
+                ctx[:initial_output_pipeline] = inherited_output_pipeline
+              end
+            end
+          end
+        end # VariableMapping
+      end
+    end
+  end
+end