trailblazer-activity-dsl-linear 0.4.3 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9953750b2e208755037a9f48a7847edc3a3ccdf54bd4ab121be8e8666b85e41f
-  data.tar.gz: 1d36eeb6036cf7a7a8fc234c78ccf90507de7f3f380a6a3fd92f432e1efe246f
+  metadata.gz: 6185e8d95445bb10e611433a6885be07ec85524cdb5d45e1aed6449610391dd1
+  data.tar.gz: e0af2bf5eba1bbb381c35675c3352ba99b5a3598964e9deffeec75d8e6b3be58
 SHA512:
-  metadata.gz: d50d156f2daed3fccf7c78d978896e4a94d5cf6ef854f9e77ace7186700703c45c1aed21a551b27f0343d4d0ed33694958be936fc6a5651505cf6b368052dd83
-  data.tar.gz: 2b53f6d85d4e0e65407cb90c82ce34be3c55e3ba6b1dfdb25ae64a04be5d19617410c91da532f09cb2ed6058eb7e28e18e11bc3e68d5f83b197ef0792d3e2b15
+  metadata.gz: 3ae89d32dddf81784df0abb2d103c3672125c80f6637e5cae76a3a460addb75e7707352a43643d8359273cb7c2e6c5e96636e19c714adebe5da657cd74d5c73e
+  data.tar.gz: c9f56bcb32fd1e1ba4adb7e8b39af43093d96a0eadb9ff21cbe35a2207a4c7b70728ee1eda7de00af1bf0972afbb51744143ff6f3d05595c6457c209f31b38c4

data/CHANGES.md

@@ -1,3 +1,9 @@
+# 0.5.0
+
+* Introduce `:inject` option to pass-through injected variables and to default input variables.
+* Remove `VariableMapping::Input::Scoped` as we're now using a separate `Pipeline` for input filtering.
+* Massively simplify (and accelerate!) the `Normalizer` layer by using `TaskWrap::Pipeline` instead of `Activity::Path`. Note that you can alter a normalizer by using the `TaskWrap::Pipeline` API now.
+
 # 0.4.3
 
 * Limit `trailblazer-activity` dependency to `< 0.13.0`.

data/Gemfile

@@ -9,4 +9,5 @@ gem "rubocop", require: false
 
 # gem "trailblazer-developer", path: "../trailblazer-developer"
 # gem "trailblazer-activity", path: "../trailblazer-activity"
+gem "trailblazer-activity", github: "trailblazer/trailblazer-activity"
 # gem "trailblazer-activity", path: "../circuit"

data/README.md

@@ -1,17 +1,17 @@
 # Activity-DSL-Linear
 
 The `activity-dsl-linear` gem brings:
-- [Path](https://2019.trailblazer.to/2.1/docs/activity.html#activity-strategy-path)
-- [Railway](https://2019.trailblazer.to/2.1/docs/activity.html#activity-strategy-railway)
-- [Fasttrack](https://2019.trailblazer.to/2.1/docs/activity.html#activity-strategy-fasttrack)
+- [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.
 
-Please find the [full documentation on the Trailblazer website](https://2019.trailblazer.to/2.1/docs/activity.html#activity-strategy). [Note that the docs are WIP.]
+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://2019.trailblazer.to/2.1/docs/activity.html#activity-strategy-railway)).
+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)).
 
 ```ruby
 require "trailblazer-activity"
@@ -79,15 +79,15 @@ With Activity, modeling business processes turns out to be ridiculously simple:
 
 ## Operation
 
-Trailblazer's [`Operation`](https://2019.trailblazer.to/2.1/docs/operation.html#operation-overview) internally uses an activity to model the processes.
+Trailblazer's [`Operation`](https://trailblazer.to/2.1/docs/operation.html#operation-overview) internally uses an activity to model the processes.
 
 ## Workflow
-Activities can be formed into bigger compounds and using workflow, you can build long-running processes such as a moderated blog post or a parcel delivery. Also, you don't have to use the DSL but can use the [`editor`](https://2019.trailblazer.to/2.1/docs/pro.html#pro-editor)instead(cool for more complex, long-running flows). Here comes a sample screenshot.
+Activities can be formed into bigger compounds and using workflow, you can build long-running processes such as a moderated blog post or a parcel delivery. Also, you don't have to use the DSL but can use the [`editor`](https://trailblazer.to/2.1/docs/pro.html#pro-editor)instead(cool for more complex, long-running flows). Here comes a sample screenshot.
 
-<img src="http://2019.trailblazer.to/2.1/dist/img/flow.png">
+<img src="http://trailblazer.to/2.1/dist/img/flow.png">
 
 ## License
 
 © Copyright 2018, Trailblazer GmbH
 
-Licensed under the LGPLv3 license. We also offer a commercial-friendly [license](https://2019.trailblazer.to/2.1/docs/pro.html#pro-license).
+Licensed under the LGPLv3 license. We also offer a commercial-friendly [license](https://trailblazer.to/2.1/docs/pro.html#pro-license).

data/lib/trailblazer/activity/dsl/linear/normalizer.rb

@@ -7,154 +7,149 @@ module Trailblazer
         module Normalizer
           module_function
 
-          #   activity_normalizer.([{options:, user_options:, normalizer_options: }])
-          def activity_normalizer(sequence)
-            seq = Activity::Path::DSL.prepend_to_path( # this doesn't particularly put the steps after the Path steps.
-              sequence,
-
-              {
-              "activity.normalize_step_interface"       => method(:normalize_step_interface),      # first
-              "activity.normalize_for_macro"            => method(:merge_user_options),
-              "activity.normalize_normalizer_options"   => method(:merge_normalizer_options),
-              "activity.normalize_context"              => method(:normalize_context),
-              "activity.normalize_id"                   => method(:normalize_id),
-              "activity.normalize_override"             => method(:normalize_override),
-              "activity.wrap_task_with_step_interface"  => method(:wrap_task_with_step_interface), # last
-              "activity.inherit_option"               => method(:inherit_option),
-              },
+          # Wrap {task} with {Trailblazer::Option} and execute it with kw args in {#call}.
+          # Note that this instance always return {Right}.
+          class Task < TaskBuilder::Task
+            def call(wrap_ctx, flow_options={})
+              result = call_option(@task, [wrap_ctx, flow_options]) # DISCUSS: this mutates {ctx}.
 
-              Linear::Insert.method(:Append), "Start.default"
-            )
+              return wrap_ctx, flow_options
+            end
+          end
 
-            seq = Trailblazer::Activity::Path::DSL.prepend_to_path( # this doesn't particularly put the steps after the Path steps.
-              seq,
+          def Task(user_proc)
+            Normalizer::Task.new(Trailblazer::Option(user_proc), user_proc)
+          end
 
+          #   activity_normalizer.([{options:, user_options:, normalizer_options: }])
+          def activity_normalizer(pipeline)
+            pipeline = TaskWrap::Pipeline.prepend(
+              pipeline,
+              nil, # this means, put it to the beginning.
               {
-              "activity.normalize_outputs_from_dsl"     => method(:normalize_outputs_from_dsl),     # Output(Signal, :semantic) => Id()
-              "activity.normalize_connections_from_dsl" => method(:normalize_connections_from_dsl),
-              "activity.input_output_dsl"               => method(:input_output_dsl), # FIXME: make this optional and allow to dynamically change normalizer steps
+              "activity.normalize_step_interface"       => Normalizer.Task(method(:normalize_step_interface)),      # first
+              "activity.normalize_for_macro"            => Normalizer.Task(method(:merge_user_options)),
+              "activity.normalize_normalizer_options"   => Normalizer.Task(method(:merge_normalizer_options)),
+              "activity.normalize_non_symbol_options"   => Normalizer.Task(method(:normalize_non_symbol_options)),
+              "activity.normalize_context"              => method(:normalize_context),
+              "activity.normalize_id"                   => Normalizer.Task(method(:normalize_id)),
+              "activity.normalize_override"             => Normalizer.Task(method(:normalize_override)),
+              "activity.wrap_task_with_step_interface"  => Normalizer.Task(method(:wrap_task_with_step_interface)), # last
+              "activity.inherit_option"                 => Normalizer.Task(method(:inherit_option)),
               },
-
-              Linear::Insert.method(:Prepend), "path.wirings"
             )
 
-            seq = Trailblazer::Activity::Path::DSL.prepend_to_path( # this doesn't particularly put the steps after the Path steps.
-              seq,
-
+            pipeline = TaskWrap::Pipeline.prepend(
+              pipeline,
+              "path.wirings",
               {
-              "activity.cleanup_options"     => method(:cleanup_options),
+              "activity.normalize_outputs_from_dsl"     => Normalizer.Task(method(:normalize_outputs_from_dsl)),     # Output(Signal, :semantic) => Id()
+              "activity.normalize_connections_from_dsl" => Normalizer.Task(method(:normalize_connections_from_dsl)),
+              "activity.input_output_dsl"               => Normalizer.Task(method(:input_output_dsl)),
               },
+            )
 
-              Linear::Insert.method(:Prepend), "End.success"
+            pipeline = TaskWrap::Pipeline.append(
+              pipeline,
+              nil,
+              ["activity.cleanup_options", method(:cleanup_options)]
             )
-# pp seq
-            seq
+
+            pipeline
           end
 
           # Specific to the "step DSL": if the first argument is a callable, wrap it in a {step_interface_builder}
           # since its interface expects the step interface, but the circuit will call it with circuit interface.
-          def normalize_step_interface((ctx, flow_options), *)
-            options = case ctx[:options]
+          def normalize_step_interface(ctx, options:, **)
+            options = case options
                       when Hash
                         # Circuit Interface
-                        task  = ctx[:options].fetch(:task)
-                        id    = ctx[:options][:id]
+                        task  = options.fetch(:task)
+                        id    = options[:id]
 
                         if task.is_a?(Symbol)
                           # step task: :find, id: :load
-                          { **ctx[:options], id: (id || task), task: Trailblazer::Option(task) }
+                          { **options, id: (id || task), task: Trailblazer::Option(task) }
                         else
                           # step task: Callable, ... (Subprocess, Proc, macros etc)
-                          ctx[:options] # NOOP
+                          options # NOOP
                         end
                       else
                         # Step Interface
                         # step :find, ...
                         # step Callable, ... (Method, Proc etc)
-                        { task: ctx[:options], wrap_task: true }
+                        { task: options, wrap_task: true }
                       end
 
-            return Trailblazer::Activity::Right, [ctx.merge(options: options), flow_options]
+            ctx[:options] = options
           end
 
-          def wrap_task_with_step_interface((ctx, flow_options), **)
-            return Trailblazer::Activity::Right, [ctx, flow_options] unless ctx[:wrap_task]
-
-            step_interface_builder = ctx[:step_interface_builder] # FIXME: use kw!
-            task                   = ctx[:task] # FIXME: use kw!
+          def wrap_task_with_step_interface(ctx, wrap_task: false, step_interface_builder:, task:, **)
+            return unless wrap_task
 
-            wrapped_task = step_interface_builder.(task)
-
-            return Trailblazer::Activity::Right, [ctx.merge(task: wrapped_task), flow_options]
+            ctx[:task] = step_interface_builder.(task)
           end
 
-          def normalize_id((ctx, flow_options), **)
-            id = ctx[:id] || ctx[:task]
-
-            return Trailblazer::Activity::Right, [ctx.merge(id: id), flow_options]
+          def normalize_id(ctx, id: false, task:, **)
+            ctx[:id] = id || task
           end
 
           # {:override} really only makes sense for {step Macro(), {override: true}} where the {user_options}
           # dictate the overriding.
-          def normalize_override((ctx, flow_options), *)
-            ctx = ctx.merge(replace: ctx[:id] || raise) if ctx[:override]
-
-            return Trailblazer::Activity::Right, [ctx, flow_options]
+          def normalize_override(ctx, id:, override: false, **)
+            return unless override
+            ctx[:replace] = (id || raise)
           end
 
           # make ctx[:options] the actual ctx
-          def merge_user_options((ctx, flow_options), *)
-            options = ctx[:options] # either a <#task> or {} from macro
-
-            ctx = ctx.merge(options: options.merge(ctx[:user_options])) # Note that the user options are merged over the macro options.
-
-            return Trailblazer::Activity::Right, [ctx, flow_options]
+          def merge_user_options(ctx, options:, **)
+            # {options} are either a <#task> or {} from macro
+            ctx[:options] = options.merge(ctx[:user_options]) # Note that the user options are merged over the macro options.
           end
 
           # {:normalizer_options} such as {:track_name} get overridden by user/macro.
-          def merge_normalizer_options((ctx, flow_options), *)
-            normalizer_options = ctx[:normalizer_options] # either a <#task> or {} from macro
-
-            ctx = ctx.merge(options: normalizer_options.merge(ctx[:options])) #
-
-            return Trailblazer::Activity::Right, [ctx, flow_options]
+          def merge_normalizer_options(ctx, normalizer_options:, options:, **)
+            ctx[:options] = normalizer_options.merge(options)
           end
 
-          def normalize_context((ctx, flow_options), *)
+          def normalize_context(ctx, flow_options)
             ctx = ctx[:options]
 
-            return Trailblazer::Activity::Right, [ctx, flow_options]
+            return ctx, flow_options
           end
 
           # Compile the actual {Seq::Row}'s {wiring}.
           # This combines {:connections} and {:outputs}
-          def compile_wirings((ctx, flow_options), *)
-            connections = ctx[:connections] || raise # FIXME
-            outputs = ctx[:outputs] || raise # FIXME
-
+          def compile_wirings(ctx, connections:, outputs:, id:, **)
             ctx[:wirings] =
               connections.collect do |semantic, (search_strategy_builder, *search_args)|
-                output = outputs[semantic] || raise("No `#{semantic}` output found for #{ctx[:id].inspect} and outputs #{outputs.inspect}")
+                output = outputs[semantic] || raise("No `#{semantic}` output found for #{id.inspect} and outputs #{outputs.inspect}")
 
                 search_strategy_builder.( # return proc to be called when compiling Seq, e.g. {ById(output, :id)}
                   output,
                   *search_args
                 )
               end
-
-            return Trailblazer::Activity::Right, [ctx, flow_options]
           end
 
-          # Process {Output(:semantic) => target}.
-          def normalize_connections_from_dsl((ctx, flow_options), *)
-            new_ctx = ctx.reject { |output, cfg| output.kind_of?(Activity::DSL::Linear::OutputSemantic) }
-            connections = new_ctx[:connections]
-            adds        = new_ctx[:adds]
+          # Move DSL user options such as {Output(:success) => Track(:found)} to
+          # a new key {options[:non_symbol_options]}.
+          # This allows using {options} as a {**ctx}-able hash in Ruby 2.6 and 3.0.
+          def normalize_non_symbol_options(ctx, options:, **)
+            symbol_options     = options.find_all { |k, v| k.is_a?(Symbol) }.to_h
+            non_symbol_options = options.slice(*(options.keys - symbol_options.keys))
+            # raise unless (symbol_options.size+non_symbol_options.size) == options.size
+
+            ctx[:options] = symbol_options.merge(non_symbol_options: non_symbol_options)
+          end
 
+          # Process {Output(:semantic) => target} and make them {:connections}.
+          def normalize_connections_from_dsl(ctx, connections:, adds:, non_symbol_options:, **)
             # Find all {Output() => Track()/Id()/End()}
-            (ctx.keys - new_ctx.keys).each do |output|
-              cfg = ctx[output]
+            output_configs = non_symbol_options.find_all{ |k,v| k.kind_of?(Activity::DSL::Linear::OutputSemantic) }
+            return unless output_configs.any?
 
+            output_configs.each do |output, cfg|
               new_connections, add =
                 if cfg.is_a?(Activity::DSL::Linear::Track)
                   [output_to_track(ctx, output, cfg), cfg.adds]
@@ -177,9 +172,8 @@ module Trailblazer
               adds += add
             end
 
-            new_ctx = new_ctx.merge(connections: connections, adds: adds)
-
-            return Trailblazer::Activity::Right, [new_ctx, flow_options]
+            ctx[:connections] = connections
+            ctx[:adds]        = adds
           end
 
           def output_to_track(ctx, output, track)
@@ -205,53 +199,38 @@ module Trailblazer
           end
 
           # Output(Signal, :semantic) => Id()
-          def normalize_outputs_from_dsl((ctx, flow_options), *)
-            new_ctx = ctx.reject { |output, cfg| output.kind_of?(Activity::Output) }
+          def normalize_outputs_from_dsl(ctx, non_symbol_options:, outputs:, **)
+            output_configs = non_symbol_options.find_all{ |k,v| k.kind_of?(Activity::Output) }
+            return unless output_configs.any?
 
-            outputs     = ctx[:outputs]
             dsl_options = {}
 
-            (ctx.keys - new_ctx.keys).collect do |output|
-              cfg      = ctx[output] # e.g. Track(:success)
-
-              outputs = outputs.merge(output.semantic => output)
+            output_configs.collect do |output, cfg| # {cfg} = Track(:success)
+              outputs     = outputs.merge(output.semantic => output)
               dsl_options = dsl_options.merge(Linear.Output(output.semantic) => cfg)
             end
 
-            new_ctx = new_ctx.merge(outputs: outputs).merge(dsl_options)
-
-            return Trailblazer::Activity::Right, [new_ctx, flow_options]
+            ctx[:outputs]            = outputs
+            ctx[:non_symbol_options] = non_symbol_options.merge(dsl_options)
           end
 
-          def input_output_dsl((ctx, flow_options), *)
-            config = ctx.select { |k,v| [:input, :output, :output_with_outer_ctx].include?(k) } # TODO: optimize this, we don't have to go through the entire hash.
-
-            return Trailblazer::Activity::Right, [ctx, flow_options] if config.size == 0 # no :input/:output passed.
+          def input_output_dsl(ctx, extensions: [], **)
+            config = ctx.select { |k,v| [:input, :output, :output_with_outer_ctx, :inject].include?(k) } # TODO: optimize this, we don't have to go through the entire hash.
+            return unless config.any? # no :input/:output/:inject passed.
 
-            new_ctx = {}
-            new_ctx[:extensions] = ctx[:extensions] || [] # merge DSL extensions with I/O.
-            new_ctx[:extensions] += [Linear.VariableMapping(**config)]
-
-            return Trailblazer::Activity::Right, [ctx.merge(new_ctx), flow_options]
+            ctx[:extensions] = extensions + [Linear.VariableMapping(**config)]
           end
 
           # Currently, the {:inherit} option copies over {:connections} from the original step
           # and merges them with the (prolly) connections passed from the user.
-          def inherit_option((ctx, flow_options), *)
-            return Trailblazer::Activity::Right, [ctx, flow_options] unless ctx[:inherit]
-
-            sequence = ctx[:sequence]
-            id = ctx[:id]
+          def inherit_option(ctx, inherit: false, sequence:, id:, extensions: [], **)
+            return unless inherit
 
             index = Linear::Insert.find_index(sequence, id)
             row   = sequence[index] # from this row we're inheriting options.
 
-            connections = get_inheritable_connections(ctx, row[3][:connections])
-            extensions  = Array(row[3][:extensions]) + Array(ctx[:extensions])
-
-            ctx = ctx.merge(connections: connections, extensions: extensions) # "inherit"
-
-            return Trailblazer::Activity::Right, [ctx, flow_options]
+            ctx[:connections] = get_inheritable_connections(ctx, row[3][:connections])
+            ctx[:extensions]  = Array(row[3][:extensions]) + Array(extensions)
           end
 
           # return connections from {parent} step which are supported by current step
@@ -262,11 +241,11 @@ module Trailblazer
           end
 
           # TODO: make this extendable!
-          def cleanup_options((ctx, flow_options), *)
+          def cleanup_options(ctx, flow_options)
             # new_ctx = ctx.reject { |k, v| [:connections, :outputs, :end_id, :step_interface_builder, :failure_end, :track_name, :sequence].include?(k) }
-            new_ctx = ctx.reject { |k, v| [:outputs, :end_id, :step_interface_builder, :failure_end, :track_name, :sequence].include?(k) }
+            new_ctx = ctx.reject { |k, v| [:outputs, :end_id, :step_interface_builder, :failure_end, :track_name, :sequence, :non_symbol_options].include?(k) }
 
-            return Trailblazer::Activity::Right, [new_ctx, flow_options]
+            return new_ctx, flow_options
           end
         end
 

data/lib/trailblazer/activity/dsl/linear/state.rb

@@ -39,27 +39,20 @@ module Trailblazer
 
           # Compiles and maintains all final normalizers for a specific DSL.
           class Normalizer
-            def compile_normalizer(normalizer_sequence)
-              process = Trailblazer::Activity::DSL::Linear::Compiler.(normalizer_sequence)
-              process.to_h[:circuit]
-            end
-
             # [gets instantiated at compile time.]
             #
             # We simply compile the activities that represent the normalizers for #step, #pass, etc.
             # This can happen at compile-time, as normalizers are stateless.
             def initialize(normalizer_sequences)
-              @normalizers = Hash[
-                normalizer_sequences.collect { |name, seq| [name, compile_normalizer(seq)] }
-              ]
+              @normalizers = normalizer_sequences
             end
 
             # Execute the specific normalizer (step, fail, pass) for a particular option set provided
             # by the DSL user. This is usually when you call Operation::step.
-            def call(name, *args)
+            def call(name, ctx)
               normalizer = @normalizers.fetch(name)
-              _signal, (options, _) = normalizer.(*args)
-              options
+              wrap_ctx, _ = normalizer.(ctx, nil)
+              wrap_ctx
             end
           end
         end # State

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

@@ -4,28 +4,164 @@ module Trailblazer
       module Linear
         # Normalizer-steps to implement {:input} and {:output}
         # Returns an Extension instance to be thrown into the `step` DSL arguments.
-        def self.VariableMapping(input: VariableMapping.default_input, output: VariableMapping.default_output, output_with_outer_ctx: false)
-          input =
-            VariableMapping::Input::Scoped.new(
-              Trailblazer::Option(VariableMapping::filter_for(input))
-            )
-
-          unscope_class = output_with_outer_ctx ? VariableMapping::Output::Unscoped::WithOuterContext : VariableMapping::Output::Unscoped
-
-          output =
-            unscope_class.new(
-              Trailblazer::Option(VariableMapping::filter_for(output))
-            )
+        def self.VariableMapping(input: nil, output: VariableMapping.default_output, output_with_outer_ctx: false, inject: [])
+          merge_instructions = VariableMapping.merge_instructions_from_dsl(input: input, output: output, output_with_outer_ctx: output_with_outer_ctx, inject: inject)
 
-          TaskWrap::Extension(
-            merge: TaskWrap::VariableMapping.merge_for(input, output, id: input.object_id), # wraps filters: {Input(input), Output(output)}
-          )
+          TaskWrap::Extension(merge: merge_instructions)
         end
 
         module VariableMapping
           module_function
 
+          # For the input filter we
+          #   1. create a separate {Pipeline} instance {pipe}. Depending on the user's options, this might have up to four steps.
+          #   2. The {pipe} is run in a lamdba {input}, the lambda returns the pipe's ctx[:input_ctx].
+          #   3. The {input} filter in turn is wrapped into an {Activity::TaskWrap::Input} object via {#merge_instructions_for}.
+          #   4. The {TaskWrap::Input} instance is then finally placed into the taskWrap as {"task_wrap.input"}.
+          #
           # @private
+          def merge_instructions_from_dsl(input:, output:, output_with_outer_ctx:, inject:)
+            # FIXME: this could (should?) be in Normalizer?
+            inject_passthrough  = inject.find_all { |name| name.is_a?(Symbol) }
+            inject_with_default = inject.find { |name| name.is_a?(Hash) } # FIXME: we only support one default hash in the DSL so far.
+
+            input_steps = [
+              ["input.init_hash", VariableMapping.method(:initial_input_hash)],
+            ]
+
+            # With only injections defined, we do not filter out anything, we use the original ctx
+            # and _add_ defaulting for injected variables.
+            if !input # only injections defined
+              input_steps << ["input.default_input", VariableMapping.method(:default_input_ctx)]
+            end
+
+            if input # :input or :input/:inject
+              input_steps << ["input.add_variables", VariableMapping.method(:add_variables)]
+
+              input_filter = Trailblazer::Option(VariableMapping::filter_for(input))
+            end
+
+            if inject_passthrough || inject_with_default
+              input_steps << ["input.add_injections", VariableMapping.method(:add_injections)] # we now allow one filter per injected variable.
+            end
+
+            if inject_passthrough || inject_with_default
+              injections = inject.collect do |name|
+                if name.is_a?(Symbol)
+                  [[name, Trailblazer::Option(->(*) { [false, name] })]] # we don't want defaulting, this return value signalizes "please pass-through, only".
+                else # we automatically assume this is a hash of callables
+                  name.collect do |_name, filter|
+                    [_name, Trailblazer::Option(->(ctx, **kws) { [true, _name, filter.(ctx, **kws)] })] # filter will compute the default value
+                  end
+                end
+              end.flatten(1).to_h
+            end
+
+            input_steps << ["input.scope", VariableMapping.method(:scope)]
+
+
+            pipe = Activity::TaskWrap::Pipeline.new(input_steps)
+
+            # gets wrapped by {VariableMapping::Input} and called there.
+            # API: @filter.([ctx, original_flow_options], **original_circuit_options)
+            # input = Trailblazer::Option(->(original_ctx, **) {  })
+            input = ->((ctx, flow_options), **circuit_options) do # This filter is called by {TaskWrap::Input#call} in the {activity} gem.
+              wrap_ctx, _ = pipe.({injections: injections, input_filter: input_filter}, [[ctx, flow_options], circuit_options])
+
+              wrap_ctx[:input_ctx]
+            end
+
+            # 1. {} empty input hash
+            # 1. input # dynamic => hash
+            # 2. input_map       => hash
+            # 3. inject          => hash
+            # 4. Input::Scoped()
+
+            unscope_class = output_with_outer_ctx ? VariableMapping::Output::Unscoped::WithOuterContext : VariableMapping::Output::Unscoped
+
+            output =
+              unscope_class.new(
+                Trailblazer::Option(VariableMapping::filter_for(output))
+              )
+
+            TaskWrap::VariableMapping.merge_instructions_for(input, output, id: input.object_id) # wraps filters: {Input(input), Output(output)}
+          end
+
+# DISCUSS: improvable sections such as merge vs hash[]=
+          def initial_input_hash(wrap_ctx, original_args)
+            wrap_ctx = wrap_ctx.merge(input_hash: {})
+
+            return wrap_ctx, original_args
+          end
+
+          # Merge all original ctx variables into the new input_ctx.
+          # This happens when no {:input} is provided.
+          def default_input_ctx(wrap_ctx, original_args)
+            ((original_ctx, _), _) = original_args
+
+            MergeVariables(original_ctx, wrap_ctx, original_args)
+          end
+
+# TODO: test {nil} default
+# FIXME: what if you don't want inject but always the value from the config?
+          # Add injected variables if they're present on
+          # the original, incoming ctx.
+          def add_injections(wrap_ctx, original_args)
+            name2filter     = wrap_ctx[:injections]
+            ((original_ctx, _), circuit_options) = original_args
+
+            injections =
+              name2filter.collect do |name, filter|
+                # DISCUSS: should we remove {is_defaulted} and infer type from {filter} or the return value?
+                is_defaulted, new_name, default_value = filter.(original_ctx, keyword_arguments: original_ctx.to_hash, **circuit_options) # FIXME: interface?           # {filter} exposes {Option} interface
+
+                original_ctx.key?(name) ?
+                  [new_name, original_ctx[name]] : (
+                    is_defaulted ? [new_name, default_value] : nil
+                  )
+              end.compact.to_h # FIXME: are we <2.6 safe here?
+
+            MergeVariables(injections, wrap_ctx, original_args)
+          end
+
+          # Implements {:input}.
+          def add_variables(wrap_ctx, original_args)
+            filter = wrap_ctx[:input_filter]
+            ((original_ctx, _), circuit_options) = original_args
+
+            # this is the actual logic.
+            variables = filter.(original_ctx, keyword_arguments: original_ctx.to_hash, **circuit_options)
+
+            MergeVariables(variables, wrap_ctx, original_args)
+          end
+
+          # Finally, create a new input ctx from all the
+          # collected input variables.
+          # This goes into the step/nested OP.
+          def scope(wrap_ctx, original_args)
+            ((_, flow_options), _) = original_args
+
+            # this is the actual context passed into the step.
+            wrap_ctx[:input_ctx] = Trailblazer::Context(
+              wrap_ctx[:input_hash],
+              {}, # mutable variables
+              flow_options[:context_options]
+            )
+
+            return wrap_ctx, original_args
+          end
+
+          # Last call in every step. Currently replaces {:input_ctx} by adding variables using {#merge}.
+          # DISCUSS: improve here?
+          def MergeVariables(variables, wrap_ctx, original_args)
+            wrap_ctx[:input_hash] = wrap_ctx[:input_hash].merge(variables)
+
+            return wrap_ctx, original_args
+          end
+
+          # @private
+          # The default {:output} filter only returns the "mutable" part of the inner ctx.
+          # This means only variables added using {inner_ctx[..]=} are merged on the outside.
           def default_output
             ->(scoped, **) do
               _wrapped, mutable = scoped.decompose # `_wrapped` is what the `:input` filter returned, `mutable` is what the task wrote to `scoped`.
@@ -33,11 +169,6 @@ module Trailblazer
             end
           end
 
-          # @private
-          def default_input
-            ->(ctx, **) { ctx }
-          end
-
           # Returns a filter proc to be called in an Option.
           # @private
           def filter_for(filter)
@@ -74,22 +205,6 @@ module Trailblazer
             end
           end
 
-          module Input
-            class Scoped
-              def initialize(filter)
-                @filter = filter
-              end
-
-              def call((original_ctx, flow_options), **circuit_options)
-                Trailblazer::Context(
-                  @filter.(original_ctx, keyword_arguments: original_ctx.to_hash, **circuit_options),
-                  {},
-                  flow_options[:context_options]
-                )
-              end
-            end
-          end
-
           module Output
             # Merge the resulting {@filter.()} hash back into the original ctx.
             # DISCUSS: do we need the original_ctx as a filter argument?
@@ -98,19 +213,20 @@ module Trailblazer
                 @filter = filter
               end
 
+              # The returned hash from {@filter} is merged with the original ctx.
               def call(new_ctx, (original_ctx, flow_options), **circuit_options)
                 original_ctx.merge(
                   call_filter(new_ctx, [original_ctx, flow_options], **circuit_options)
                 )
               end
 
-              def call_filter(new_ctx, (original_ctx, flow_options), **circuit_options)
+              def call_filter(new_ctx, (_original_ctx, _flow_options), **circuit_options)
                 # Pass {inner_ctx, **inner_ctx}
                 @filter.(new_ctx, keyword_arguments: new_ctx.to_hash, **circuit_options)
               end
 
               class WithOuterContext < Unscoped
-                def call_filter(new_ctx, (original_ctx, flow_options), **circuit_options)
+                def call_filter(new_ctx, (original_ctx, _flow_options), **circuit_options)
                   # Pass {inner_ctx, outer_ctx, **inner_ctx}
                   @filter.(new_ctx, original_ctx, keyword_arguments: new_ctx.to_hash, **circuit_options)
                 end

data/lib/trailblazer/activity/dsl/linear/version.rb

@@ -3,7 +3,7 @@ module Trailblazer
     module Activity
       module DSL
         module Linear
-          VERSION = "0.4.3"
+          VERSION = "0.5.0"
         end
       end
     end

data/lib/trailblazer/activity/fast_track.rb

@@ -6,7 +6,7 @@ module Trailblazer
       end
     end
 
-    # Implementation module that can be passed to `Activity[]`.
+    # Implementation module that can be passed to `Activity()`.
     class FastTrack
       Linear = Activity::DSL::Linear
 
@@ -22,105 +22,97 @@ module Trailblazer
         end
 
         def normalizer_for_fail
-          sequence = step_options(Trailblazer::Activity::Railway::DSL.normalizer_for_fail)
+          pipeline = step_options(Trailblazer::Activity::Railway::DSL.normalizer_for_fail)
 
-          Path::DSL.prepend_to_path(
-            sequence,
+          TaskWrap::Pipeline.prepend(
+            pipeline,
+            "path.wirings",
 
             {
-              "fast_track.fail_fast_option_for_fail"  => method(:fail_fast_option_for_fail),
-            },
-            Linear::Insert.method(:Prepend), "path.wirings"
+              "fast_track.fail_fast_option_for_fail"  => Linear::Normalizer.Task(method(:fail_fast_option_for_fail)),
+            }
           )
         end
 
         def normalizer_for_pass
-          sequence = step_options(Trailblazer::Activity::Railway::DSL.normalizer_for_pass)
+          pipeline = step_options(Trailblazer::Activity::Railway::DSL.normalizer_for_pass)
 
-          Path::DSL.prepend_to_path(
-            sequence,
+          TaskWrap::Pipeline.prepend(
+            pipeline,
+            "path.wirings",
 
             {
-              "fast_track.pass_fast_option_for_pass"  => method(:pass_fast_option_for_pass),
-            },
-            Linear::Insert.method(:Prepend), "path.wirings"
+              "fast_track.pass_fast_option_for_pass"  => Linear::Normalizer.Task(method(:pass_fast_option_for_pass)),
+            }
           )
         end
 
-        def step_options(sequence)
-          Path::DSL.prepend_to_path( # this doesn't particularly put the steps after the Path steps.
-            sequence,
+        def step_options(pipeline)
+          TaskWrap::Pipeline.prepend(
+            pipeline,
+            "path.wirings",
 
             {
-              "fast_track.pass_fast_option"  => method(:pass_fast_option),
-              "fast_track.fail_fast_option"  => method(:fail_fast_option),
-              "fast_track.fast_track_option" => method(:fast_track_option),
-            },
-            Linear::Insert.method(:Prepend), "path.wirings"
+              "fast_track.pass_fast_option"  => Linear::Normalizer.Task(method(:pass_fast_option)),
+              "fast_track.fail_fast_option"  => Linear::Normalizer.Task(method(:fail_fast_option)),
+              "fast_track.fast_track_option" => Linear::Normalizer.Task(method(:fast_track_option)),
+            }
           )
         end
 
-        def pass_fast_option((ctx, flow_options), *)
-          ctx = merge_connections_for(ctx, ctx, :pass_fast, :success)
+        def pass_fast_option(ctx, **)
+          ctx = merge_connections_for!(ctx, :pass_fast, :success, **ctx)
 
-          ctx = merge_connections_for(ctx, ctx, :pass_fast, :pass_fast, :pass_fast)
-          ctx = merge_outputs_for(ctx,
-            pass_fast: Activity.Output(Activity::FastTrack::PassFast, :pass_fast),
+          ctx = merge_connections_for!(ctx, :pass_fast, :pass_fast, :pass_fast, **ctx)
+          ctx = merge_outputs_for!(ctx,
+            {pass_fast: Activity.Output(Activity::FastTrack::PassFast, :pass_fast)},
+            **ctx
           )
-
-          return Right, [ctx, flow_options]
         end
 
-        def pass_fast_option_for_pass((ctx, flow_options), *)
-          ctx = merge_connections_for(ctx, ctx, :pass_fast, :failure)
-          ctx = merge_connections_for(ctx, ctx, :pass_fast, :success)
-
-          return Right, [ctx, flow_options]
+        def pass_fast_option_for_pass(ctx, **)
+          ctx = merge_connections_for!(ctx, :pass_fast, :failure, **ctx)
+          ctx = merge_connections_for!(ctx, :pass_fast, :success, **ctx)
         end
 
-        def fail_fast_option((ctx, flow_options), *)
-          ctx = merge_connections_for(ctx, ctx, :fail_fast, :failure)
+        def fail_fast_option(ctx, **)
+          ctx = merge_connections_for!(ctx, :fail_fast, :failure, **ctx)
 
-          ctx = merge_connections_for(ctx, ctx, :fail_fast, :fail_fast, :fail_fast)
-          ctx = merge_outputs_for(ctx,
-            fail_fast: Activity.Output(Activity::FastTrack::FailFast, :fail_fast),
+          ctx = merge_connections_for!(ctx, :fail_fast, :fail_fast, :fail_fast, **ctx)
+          ctx = merge_outputs_for!(ctx,
+            {fail_fast: Activity.Output(Activity::FastTrack::FailFast, :fail_fast)},
+            **ctx
           )
-
-          return Right, [ctx, flow_options]
         end
 
-        def fail_fast_option_for_fail((ctx, flow_options), *)
-          ctx = merge_connections_for(ctx, ctx, :fail_fast, :failure)
-          ctx = merge_connections_for(ctx, ctx, :fail_fast, :success)
-
-          return Right, [ctx, flow_options]
+        def fail_fast_option_for_fail(ctx, **)
+          ctx = merge_connections_for!(ctx, :fail_fast, :failure, **ctx)
+          ctx = merge_connections_for!(ctx, :fail_fast, :success, **ctx)
         end
 
-        def fast_track_option((ctx, flow_options), *)
-          return Right, [ctx, flow_options] unless ctx[:fast_track]
+        def fast_track_option(ctx, fast_track: false, **)
+          return unless fast_track
 
-          ctx = merge_connections_for(ctx, ctx, :fast_track, :fail_fast, :fail_fast)
-          ctx = merge_connections_for(ctx, ctx, :fast_track, :pass_fast, :pass_fast)
+          ctx = merge_connections_for!(ctx, :fast_track, :fail_fast, :fail_fast, **ctx)
+          ctx = merge_connections_for!(ctx, :fast_track, :pass_fast, :pass_fast, **ctx)
 
-          ctx = merge_outputs_for(ctx,
-            pass_fast: Activity.Output(Activity::FastTrack::PassFast, :pass_fast),
-            fail_fast: Activity.Output(Activity::FastTrack::FailFast, :fail_fast),
+          ctx = merge_outputs_for!(ctx,
+            {pass_fast: Activity.Output(Activity::FastTrack::PassFast, :pass_fast),
+                        fail_fast: Activity.Output(Activity::FastTrack::FailFast, :fail_fast)},
+            **ctx
           )
-
-          return Right, [ctx, flow_options]
         end
 
-        def merge_connections_for(ctx, options, option_name, semantic, magnetic_to=option_name)
-          return ctx unless options[option_name]
+        def merge_connections_for!(ctx, option_name, semantic, magnetic_to=option_name, connections:, **)
+          return ctx unless ctx[option_name]
 
-          connections  = ctx[:connections].merge(semantic => [Linear::Search.method(:Forward), magnetic_to])
-          ctx          = ctx.merge(connections: connections)
+          ctx[:connections] = connections.merge(semantic => [Linear::Search.method(:Forward), magnetic_to])
+          ctx
         end
 
-        def merge_outputs_for(ctx, outputs)
-          ctx = ctx.merge(
-            outputs: outputs.merge(ctx[:outputs])
-          )
+        def merge_outputs_for!(ctx, new_outputs, outputs:, **)
+          ctx[:outputs] = new_outputs.merge(outputs)
+          ctx
         end
 
         def initial_sequence(initial_sequence:, fail_fast_end: Activity::End.new(semantic: :fail_fast), pass_fast_end: Activity::End.new(semantic: :pass_fast), **_o)
@@ -166,7 +158,6 @@ module Trailblazer
       extend Activity::DSL::Linear::Strategy
 
       initialize!(Railway::DSL::State.new(**DSL.OptionsForState()))
-
     end # FastTrack
   end
 end

data/lib/trailblazer/activity/path.rb

@@ -9,20 +9,30 @@ module Trailblazer
         module_function
 
         def normalizer
-          prepend_step_options(
-            initial_sequence(track_name: :success, end_task: Activity::End.new(semantic: :success), end_id: "End.success")
-          )
+          TaskWrap::Pipeline.new(normalizer_steps.to_a)
+        end
+
+        # Return {Path::Normalizer} sequence.
+        private def normalizer_steps
+          {
+            "path.outputs"                => Linear::Normalizer.Task(method(:merge_path_outputs)),
+            "path.connections"            => Linear::Normalizer.Task(method(:merge_path_connections)),
+            "path.sequence_insert"        => Linear::Normalizer.Task(method(:normalize_sequence_insert)),
+            "path.normalize_duplications" => Linear::Normalizer.Task(method(:normalize_duplications)),
+            "path.magnetic_to"            => Linear::Normalizer.Task(method(:normalize_magnetic_to)),
+            "path.wirings"                => Linear::Normalizer.Task(Linear::Normalizer.method(:compile_wirings)),
+          }
         end
 
         def start_sequence(track_name:)
           start_default = Activity::Start.new(semantic: :default)
           start_event   = Linear::Sequence.create_row(task: start_default, id: "Start.default", magnetic_to: nil, wirings: [Linear::Search::Forward(unary_outputs[:success], track_name)])
-          _sequence      = Linear::Sequence[start_event]
+          _sequence     = Linear::Sequence[start_event]
         end
 
         # DISCUSS: still not sure this should sit here.
         # Pseudo-DSL that prepends {steps} to {sequence}.
-        def prepend_to_path(sequence, steps, insertion_method=Linear::Insert.method(:Prepend), insert_id="End.success")
+        def prepend_to_path(sequence, steps, insertion_method=Linear::Insert.method(:Prepend), insert_id="End.success") # FIXME: where do we need you?
           new_rows = steps.collect do |id, task|
             Linear::Sequence.create_row(
               task:         task,
@@ -43,32 +53,24 @@ module Trailblazer
           {success: [Linear::Search.method(:Forward), track_name]}
         end
 
-        def merge_path_outputs((ctx, flow_options), *)
-          ctx = {outputs: unary_outputs}.merge(ctx)
-
-          return Right, [ctx, flow_options]
+        def merge_path_outputs(ctx, outputs: nil, **)
+          ctx[:outputs] = outputs || unary_outputs
         end
 
-        def merge_path_connections((ctx, flow_options), *)
-          raise unless track_name = ctx[:track_name]# TODO: make track_name required kw.
-          ctx = {connections: unary_connections(track_name: track_name)}.merge(ctx)
-
-          return Right, [ctx, flow_options]
+        def merge_path_connections(ctx, track_name:, connections: nil, **)
+          ctx[:connections] = connections || unary_connections(track_name: track_name)
         end
 
         # Processes {:before,:after,:replace,:delete} options and
         # defaults to {before: "End.success"} which, yeah.
-        def normalize_sequence_insert((ctx, flow_options), *)
+        def normalize_sequence_insert(ctx, end_id:, **)
           insertion = ctx.keys & sequence_insert_options.keys
           insertion = insertion[0]   || :before
-          raise if ctx[:end_id].nil? # FIXME
-          target    = ctx[insertion] || ctx[:end_id]
+          target    = ctx[insertion] || end_id
 
           insertion_method = sequence_insert_options[insertion]
 
-          ctx = ctx.merge(sequence_insert: [Linear::Insert.method(insertion_method), target])
-
-          return Right, [ctx, flow_options]
+          ctx[:sequence_insert] = [Linear::Insert.method(insertion_method), target]
         end
 
         # @private
@@ -81,51 +83,25 @@ module Trailblazer
           }
         end
 
-        def normalize_duplications((ctx, flow_options), *)
-          return Right, [ctx, flow_options] if ctx[:replace]
-
-          signal, (ctx, flow_options) = raise_on_duplicate_id([ctx, flow_options])
-          signal, (ctx, flow_options) = clone_duplicate_activity([ctx, flow_options])
+        def normalize_duplications(ctx, replace: false, **)
+          return if replace
 
-          return signal, [ctx, flow_options]
+          raise_on_duplicate_id(ctx, **ctx)
+          clone_duplicate_activity(ctx, **ctx) # DISCUSS: mutates {ctx}.
         end
 
-        def raise_on_duplicate_id((ctx, flow_options), *)
-          id, sequence = ctx[:id], ctx[:sequence]
+        def raise_on_duplicate_id(ctx, id:, sequence:, **)
           raise "ID #{id} is already taken. Please specify an `:id`." if sequence.find { |row| row[3][:id] == id }
-
-          return Right, [ctx, flow_options]
-        end
-
-        def clone_duplicate_activity((ctx, flow_options), *)
-          return Right, [ctx, flow_options] unless ctx[:task].is_a?(Class)
-
-          task, sequence = ctx[:task], ctx[:sequence]
-          ctx = ctx.merge(task: task.clone) if sequence.find { |row| row[1] == task }
-
-          return Right, [ctx, flow_options]
         end
 
-        def normalize_magnetic_to((ctx, flow_options), *) # TODO: merge with Railway.merge_magnetic_to
-          raise unless track_name = ctx[:track_name]# TODO: make track_name required kw.
-
-          ctx = {magnetic_to: track_name}.merge(ctx)
+        def clone_duplicate_activity(ctx, task:, sequence:, **)
+          return unless task.is_a?(Class)
 
-          return Right, [ctx, flow_options]
+          ctx[:task] = task.clone if sequence.find { |row| row[1] == task }
         end
 
-        # Return {Path::Normalizer} sequence.
-        def prepend_step_options(sequence)
-          prepend_to_path(
-            sequence,
-
-            "path.outputs"                => method(:merge_path_outputs),
-            "path.connections"            => method(:merge_path_connections),
-            "path.sequence_insert"        => method(:normalize_sequence_insert),
-            "path.normalize_duplications" => method(:normalize_duplications),
-            "path.magnetic_to"            => method(:normalize_magnetic_to),
-            "path.wirings"                => Linear::Normalizer.method(:compile_wirings),
-          )
+        def normalize_magnetic_to(ctx, track_name:, **) # TODO: merge with Railway.merge_magnetic_to
+          ctx[:magnetic_to] = ctx.key?(:magnetic_to) ? ctx[:magnetic_to] : track_name # FIXME: can we be magnetic_to {nil}?
         end
 
         # Returns an initial two-step sequence with {Start.default > End.success}.
@@ -161,7 +137,7 @@ module Trailblazer
         # DISCUSS: maybe make this a function?
         # These are the normalizers for an {Activity}, to be injected into a State.
         Normalizers = Linear::State::Normalizer.new(
-          step:  Linear::Normalizer.activity_normalizer( Path::DSL.normalizer ), # here, we extend the generic FastTrack::step_normalizer with the Activity-specific DSL
+          step:  Linear::Normalizer.activity_normalizer(Path::DSL.normalizer), # here, we extend the generic FastTrack::step_normalizer with the Activity-specific DSL
         )
 
         # pp Normalizers
@@ -198,7 +174,7 @@ module Trailblazer
       initialize!(Path::DSL::State.new(**DSL.OptionsForState()))
     end # Path
 
-    def self.Path(options)
+    def self.Path(**options)
       Class.new(Path) do
         initialize!(Path::DSL::State.new(**Path::DSL.OptionsForState(**options)))
       end

data/lib/trailblazer/activity/railway.rb

@@ -15,95 +15,74 @@ module Trailblazer
         # TODO: make this easier, even at this step.
 
         def normalizer_for_fail
-          sequence = normalizer
-
-          id = "railway.magnetic_to.fail"
-          task = Fail.method(:merge_magnetic_to)
-
-# TODO: use prepend_to_path
-          sequence = Linear::DSL.insert_task(sequence,
-            task: task,
-            magnetic_to: :success, id: id,
-            wirings: [Linear::Search.Forward(Path::DSL.unary_outputs[:success], :success)],
-            sequence_insert: [Linear::Insert.method(:Prepend), "path.wirings"])
-
-          id = "railway.connections.fail.success_to_failure"
-          task = Fail.method(:connect_success_to_failure)
-
-          sequence = Linear::DSL.insert_task(sequence,
-            task: task,
-            magnetic_to: :success, id: id,
-            wirings: [Linear::Search.Forward(Path::DSL.unary_outputs[:success], :success)],
-            sequence_insert: [Linear::Insert.method(:Replace), "path.connections"])
+          pipeline = TaskWrap::Pipeline.prepend(
+            normalizer,
+            "path.wirings",
+            {
+              "railway.magnetic_to.fail" => Linear::Normalizer.Task(Fail.method(:merge_magnetic_to)),
+            }
+          )
+
+          pipeline = TaskWrap::Pipeline.prepend(
+            pipeline,
+            "path.connections",
+            {
+              "railway.connections.fail.success_to_failure" => Linear::Normalizer.Task(Fail.method(:connect_success_to_failure)),
+            },
+            replace: 1 # replace {"path.connections"}
+          )
         end
 
         def normalizer_for_pass
-          sequence = normalizer
-
-          id = "railway.connections.pass.failure_to_success"
-          task = Pass.method(:connect_failure_to_success)
-
-          sequence = Linear::DSL.insert_task(sequence,
-            task: task,
-            magnetic_to: :success, id: id,
-            wirings: [Linear::Search.Forward(Path::DSL.unary_outputs[:success], :success)],
-            sequence_insert: [Linear::Insert.method(:Append), "path.connections"])
+          pipeline = TaskWrap::Pipeline.insert_after(
+            normalizer,
+            "path.connections",
+            ["railway.connections.pass.failure_to_success", Linear::Normalizer.Task(Pass.method(:connect_failure_to_success))],
+          )
         end
 
         module Fail
           module_function
 
-          def merge_magnetic_to((ctx, flow_options), *)
-            ctx = ctx.merge(magnetic_to: :failure)
-
-            return Right, [ctx, flow_options]
+          def merge_magnetic_to(ctx, **)
+            ctx[:magnetic_to] = :failure
           end
 
-          def connect_success_to_failure((ctx, flow_options), *)
-            ctx = {connections: {success: [Linear::Search.method(:Forward), :failure]}}.merge(ctx)
-
-            return Right, [ctx, flow_options]
+          def connect_success_to_failure(ctx, connections: nil, **)
+            ctx[:connections] = connections || {success: [Linear::Search.method(:Forward), :failure]}
           end
         end
 
         module Pass
           module_function
 
-          def connect_failure_to_success((ctx, flow_options), *)
-            connections = ctx[:connections].merge({failure: [Linear::Search.method(:Forward), :success]})
-
-            return Right, [ctx.merge(connections: connections), flow_options]
+          def connect_failure_to_success(ctx, connections:, **)
+            ctx[:connections] = connections.merge({failure: [Linear::Search.method(:Forward), :success]})
           end
         end
 
         # Add {Railway} steps to normalizer path.
-        def step_options(sequence)
-          Path::DSL.prepend_to_path( # this doesn't particularly put the steps after the Path steps.
-            sequence,
-
+        def step_options(pipeline)
+          TaskWrap::Pipeline.prepend(
+            pipeline,
+            "path.wirings",
             {
-              "railway.outputs"     => method(:normalize_path_outputs),
-              "railway.connections" => method(:normalize_path_connections),
+              "railway.outputs"     => Linear::Normalizer.Task(method(:normalize_path_outputs)),
+              "railway.connections" => Linear::Normalizer.Task(method(:normalize_path_connections)),
             },
-
-            Linear::Insert.method(:Prepend), "path.wirings" # override where it's added.
           )
         end
 
         # Add {:failure} output to {:outputs}.
         # TODO: assert that failure_outputs doesn't override existing {:outputs}
-        def normalize_path_outputs((ctx, flow_options), *)
-          outputs = failure_outputs.merge(ctx[:outputs])
-          ctx     = ctx.merge(outputs: outputs)
+        def normalize_path_outputs(ctx, outputs:, **)
+          outputs = failure_outputs.merge(outputs)
 
-          return Right, [ctx, flow_options]
+          ctx[:outputs] = outputs
         end
 
-        def normalize_path_connections((ctx, flow_options), *)
-          connections = failure_connections.merge(ctx[:connections])
-          ctx         = ctx.merge(connections: connections)
-
-          return Right, [ctx, flow_options]
+        def normalize_path_connections(ctx, connections:, **)
+          ctx[:connections] = failure_connections.merge(connections)
         end
 
         def failure_outputs
@@ -115,16 +94,16 @@ module Trailblazer
 
         def initial_sequence(failure_end:, initial_sequence:, **path_options)
           # TODO: this could be an Activity itself but maybe a bit too much for now.
-          sequence = Path::DSL.append_end(initial_sequence, task: failure_end, magnetic_to: :failure, id: "End.failure")
+          _seq = Path::DSL.append_end(initial_sequence, task: failure_end, magnetic_to: :failure, id: "End.failure")
         end
 
         class State < Path::DSL::State
           def fail(*args)
-            seq = Linear::Strategy.task_for!(self, :fail, *args) # mutate @state
+            _seq = Linear::Strategy.task_for!(self, :fail, *args) # mutate @state
           end
 
           def pass(*args)
-            seq = Linear::Strategy.task_for!(self, :pass, *args) # mutate @state
+            _seq = Linear::Strategy.task_for!(self, :pass, *args) # mutate @state
           end
         end # Instance
 
@@ -162,7 +141,6 @@ module Trailblazer
       extend DSL::Linear::Strategy
 
       initialize!(Railway::DSL::State.new(**DSL.OptionsForState()))
-
     end # Railway
 
     def self.Railway(options)

data/trailblazer-activity-dsl-linear.gemspec

@@ -19,7 +19,7 @@ Gem::Specification.new do |spec|
   end
   spec.require_paths = ["lib"]
 
-  spec.add_dependency "trailblazer-activity", ">= 0.12.2", "< 0.13.0"
+  spec.add_dependency "trailblazer-activity", ">= 0.13.0", "< 1.0.0"
 
   spec.add_development_dependency "bundler"
   spec.add_development_dependency "minitest", "~> 5.0"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: trailblazer-activity-dsl-linear
 version: !ruby/object:Gem::Version
-  version: 0.4.3
+  version: 0.5.0
 platform: ruby
 authors:
 - Nick Sutterer
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-11-26 00:00:00.000000000 Z
+date: 2021-12-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: trailblazer-activity
@@ -16,20 +16,20 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.12.2
+        version: 0.13.0
     - - "<"
       - !ruby/object:Gem::Version
-        version: 0.13.0
+        version: 1.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.12.2
+        version: 0.13.0
     - - "<"
       - !ruby/object:Gem::Version
-        version: 0.13.0
+        version: 1.0.0
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement