trailblazer-activity-dsl-linear 1.0.0 → 1.2.0

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

@@ -16,6 +16,15 @@ class Trailblazer::Activity
           Trailblazer::Activity::Adds::Insert.method(name)
         end
       end
+
+      module Deprecate
+        # Used in combination with `Activity::Deprecate.warn`. Guesses the location
+        # of the method call from the stacktrace.
+        def self.dsl_caller_location
+          caller_index = caller_locations.find_index { |location| location.to_s =~ /recompile_activity_for/ }
+          caller_index ? caller_locations[caller_index + 2] : caller_locations[0]
+        end
+      end
     end # Linear
   end
 end
@@ -24,6 +33,9 @@ require "trailblazer/activity/dsl/linear/sequence"
 require "trailblazer/activity/dsl/linear/sequence/builder"
 require "trailblazer/activity/dsl/linear/sequence/search"
 require "trailblazer/activity/dsl/linear/sequence/compiler"
+require "trailblazer/activity/dsl/linear/normalizer/inherit" # DISCUSS. should we add normalizer/options/... or something?
+require "trailblazer/activity/dsl/linear/normalizer/extensions"
+require "trailblazer/activity/dsl/linear/normalizer/output_tuples"
 require "trailblazer/activity/dsl/linear/normalizer"
 require "trailblazer/activity/dsl/linear/normalizer/terminus"
 require "trailblazer/activity/dsl/linear/helper"
@@ -34,8 +46,8 @@ require "trailblazer/activity/railway"
 require "trailblazer/activity/fast_track"
 require "trailblazer/activity/dsl/linear/feature/variable_mapping"
 require "trailblazer/activity/dsl/linear/feature/variable_mapping/dsl"
+require "trailblazer/activity/dsl/linear/feature/variable_mapping/runtime"
 require "trailblazer/activity/dsl/linear/feature/patch"
-require "trailblazer/activity/dsl/linear/feature/variable_mapping/inherit"
 
 # feature/variable_mapping
 Trailblazer::Activity::DSL::Linear::VariableMapping.extend!(Trailblazer::Activity::Path, :step)

data/lib/trailblazer/activity/fast_track.rb

@@ -2,63 +2,120 @@ module Trailblazer
   class Activity
     # Implementation of the "FastTrack" layout that is also used for `Operation`.
     class FastTrack < Activity::DSL::Linear::Strategy
-
       # Signals
       FailFast = Class.new(Signal)
       PassFast = Class.new(Signal)
 
       module DSL
         Linear = Activity::DSL::Linear
+        # The connector logic needs to be run before Railway's connector logic:
+        PREPEND_TO = "activity.path_helper.path_to_track"
 
         module_function
 
-        def Normalizer(base_normalizer=Trailblazer::Activity::Railway::DSL.Normalizer())
-          Linear::Normalizer.prepend_to(
-            base_normalizer,
-            "activity.wirings",
+        def Normalizer(prepend_to_default_outputs: [], base_normalizer_builder: Railway::DSL.method(:Normalizer))
+          fast_track_output_steps = {
+            "fast_track.pass_fast_output"     => Linear::Normalizer.Task(method(:add_pass_fast_output)),
+            "fast_track.fail_fast_output"     => Linear::Normalizer.Task(method(:add_fail_fast_output)),
+            "fast_track.fast_track_outputs"   => Linear::Normalizer.Task(method(:add_fast_track_outputs)),
+          }
+
+          # Retrieve the base normalizer from {linear/normalizer.rb} and add processing steps.
+          step_normalizer = base_normalizer_builder.call( # E.g Railway::DSL.NormalizerForPass.
+            prepend_to_default_outputs: [fast_track_output_steps, *prepend_to_default_outputs]
+          )
 
+          _normalizer = Linear::Normalizer.prepend_to(
+            step_normalizer,
+            PREPEND_TO,
             {
-              "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)),
+              "fast_track.record_options"     => Linear::Normalizer.Task(method(:record_options)),
+              "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(:add_fast_track_connectors)),
             }
           )
         end
 
-        def NormalizerForFail
-          pipeline = Normalizer(Railway::DSL.NormalizerForFail())
+        module Fail
+          module_function
 
-          Linear::Normalizer.prepend_to(
-            pipeline,
-            "activity.wirings",
+          def Normalizer
+            pipeline = DSL.Normalizer(base_normalizer_builder: Railway::DSL::Fail.method(:Normalizer))
 
-            {
-              "fast_track.fail_fast_option_for_fail"  => Linear::Normalizer.Task(method(:fail_fast_option_for_fail)),
-            }
-          )
+            Linear::Normalizer.prepend_to(
+              pipeline,
+              PREPEND_TO,
+              {
+                "fast_track.fail_fast_option_for_fail"  => Linear::Normalizer.Task(DSL.method(:fail_fast_option_for_fail)),
+              }
+            )
+          end
         end
 
-        def NormalizerForPass
-          pipeline = Normalizer(Railway::DSL.NormalizerForPass())
+        module Pass
+          module_function
 
-          Linear::Normalizer.prepend_to(
-            pipeline,
-            "activity.wirings",
+          def Normalizer
+            pipeline = DSL.Normalizer(base_normalizer_builder: Railway::DSL::Pass.method(:Normalizer))
 
-            {
-              "fast_track.pass_fast_option_for_pass"  => Linear::Normalizer.Task(method(:pass_fast_option_for_pass)),
-            }
+            Linear::Normalizer.prepend_to(
+              pipeline,
+              PREPEND_TO,
+              {
+                "fast_track.pass_fast_option_for_pass"  => Linear::Normalizer.Task(DSL.method(:pass_fast_option_for_pass)),
+              }
+            )
+          end
+        end
+
+        # inherit: true
+        RECORD_OPTIONS = [:pass_fast, :fail_fast, :fast_track]
+
+        # *If* {fast_track: true} (or :pass_fast or :fail_fast), record it using Normalizer::Inherit mechanics.
+        def record_options(ctx, non_symbol_options:, **)
+          recorded_options =
+            RECORD_OPTIONS.collect { |option| ctx.key?(option) ? [option, ctx[option]] : nil }
+              .compact
+              .to_h
+
+          ctx.merge!(
+            non_symbol_options: non_symbol_options.merge(
+              Linear::Normalizer::Inherit.Record(recorded_options, type: :fast_track, non_symbol_options: false)
+            )
           )
         end
 
+        def add_pass_fast_output(ctx, outputs:, pass_fast: nil, **)
+          return unless pass_fast
+
+          ctx[:outputs] = PASS_FAST_OUTPUT.merge(outputs)
+        end
+
+        def add_fail_fast_output(ctx, outputs:, fail_fast: nil, **)
+          return unless fail_fast
+
+          ctx[:outputs] = FAIL_FAST_OUTPUT.merge(outputs)
+        end
+
+        def add_fast_track_outputs(ctx, outputs:, fast_track: nil, **)
+          return unless fast_track
+
+          ctx[:outputs] = FAIL_FAST_OUTPUT.merge(PASS_FAST_OUTPUT).merge(outputs)
+        end
+
+        PASS_FAST_OUTPUT = {pass_fast: Activity.Output(Activity::FastTrack::PassFast, :pass_fast)}
+        FAIL_FAST_OUTPUT = {fail_fast: Activity.Output(Activity::FastTrack::FailFast, :fail_fast)}
+
+        def add_fast_track_connectors(ctx, fast_track: nil, **)
+          ctx = merge_connections_for!(ctx, :fast_track, :pass_fast, :pass_fast, **ctx)
+          ctx = merge_connections_for!(ctx, :fast_track, :fail_fast, :fail_fast, **ctx)
+        end
+
         def pass_fast_option(ctx, **)
           ctx = merge_connections_for!(ctx, :pass_fast, :success, **ctx)
 
           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
-          )
         end
 
         def pass_fast_option_for_pass(ctx, **)
@@ -70,10 +127,6 @@ module Trailblazer
           ctx = merge_connections_for!(ctx, :fail_fast, :failure, **ctx)
 
           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
-          )
         end
 
         def fail_fast_option_for_fail(ctx, **)
@@ -81,54 +134,30 @@ module Trailblazer
           ctx = merge_connections_for!(ctx, :fail_fast, :success, **ctx)
         end
 
-        def fast_track_option(ctx, fast_track: false, **)
-          return unless fast_track
-
-          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
-          )
-        end
-
-        def merge_connections_for!(ctx, option_name, semantic, magnetic_to=option_name, connections:, **)
+        def merge_connections_for!(ctx, option_name, semantic, magnetic_to=option_name, non_symbol_options:, **)
           return ctx unless ctx[option_name]
 
-          ctx[:connections] = connections.merge(semantic => [Linear::Sequence::Search.method(:Forward), magnetic_to])
-          ctx
-        end
+          connector = {Linear::Normalizer::OutputTuples.Output(semantic) => Linear::Strategy.Track(magnetic_to)}
 
-        def merge_outputs_for!(ctx, new_outputs, outputs:, **)
-          ctx[:outputs] = new_outputs.merge(outputs)
+          ctx[:non_symbol_options] = connector.merge(non_symbol_options)
           ctx
         end
 
-        def initial_sequence(sequence:, fail_fast_end: Activity::End.new(semantic: :fail_fast), pass_fast_end: Activity::End.new(semantic: :pass_fast), **)
-          sequence = Path::DSL.append_terminus(sequence, fail_fast_end, magnetic_to: :fail_fast, id: "End.fail_fast", normalizers: Normalizers)
-          sequence = Path::DSL.append_terminus(sequence, pass_fast_end, magnetic_to: :pass_fast, id: "End.pass_fast", normalizers: Normalizers)
-        end
-
         # Normalizer pipelines taking care of processing your DSL options.
         Normalizers = Linear::Normalizer::Normalizers.new(
           step: FastTrack::DSL.Normalizer(),
-          fail: FastTrack::DSL.NormalizerForFail(),
-          pass: FastTrack::DSL.NormalizerForPass(),
+          fail: FastTrack::DSL::Fail.Normalizer(),
+          pass: FastTrack::DSL::Pass.Normalizer(),
           terminus: Linear::Normalizer::Terminus.Normalizer(),
         )
 
-        def self.OptionsForSequenceBuilder(**options)
+        def options_for_sequence_build(fail_fast_end: Activity::End.new(semantic: :fail_fast), pass_fast_end: Activity::End.new(semantic: :pass_fast), **options)
+          fail_fast_terminus_options = [fail_fast_end, magnetic_to: :fail_fast, id: "End.fail_fast", normalizers: Normalizers]
+          past_fast_terminus_options = [pass_fast_end, magnetic_to: :pass_fast, id: "End.pass_fast", normalizers: Normalizers]
 
-          options = Railway::DSL.OptionsForSequenceBuilder(**options)
+          railway_options, railway_termini = Railway::DSL.options_for_sequence_build(**options)
 
-          initial_sequence = DSL.initial_sequence(**options)
-
-          {
-            **options,
-            sequence: initial_sequence,
-          }
+          return railway_options, railway_termini + [fail_fast_terminus_options, past_fast_terminus_options]
         end
       end # DSL
 

data/lib/trailblazer/activity/path.rb

@@ -5,39 +5,43 @@ module Trailblazer
       # Functions that help creating a path-specific sequence.
       module DSL
         Linear = Activity::DSL::Linear
+        # Always prepend all "add connectors" steps of all normalizers to normalize_output_tuples.
+        # This assures that the order is
+        #   [<default tuples>, <inherited tuples>, <user tuples>]
+        PREPEND_TO = "output_tuples.normalize_output_tuples"
 
         module_function
 
-        def Normalizer
+        def Normalizer(prepend_to_default_outputs: [])
+          path_output_steps = {
+            "path.outputs" => Linear::Normalizer.Task(method(:add_success_output))
+          }
+
           # Retrieve the base normalizer from {linear/normalizer.rb} and add processing steps.
-          dsl_normalizer = Linear::Normalizer.Normalizer()
+          dsl_normalizer = Linear::Normalizer.Normalizer(
+            prepend_to_default_outputs: [*prepend_to_default_outputs, path_output_steps]
+          )
 
           Linear::Normalizer.prepend_to(
             dsl_normalizer,
-            # "activity.wirings",
-            "activity.normalize_outputs_from_dsl",
+            PREPEND_TO,
             {
-              "path.outputs"                => Linear::Normalizer.Task(method(:merge_path_outputs)),
-              "path.connections"            => Linear::Normalizer.Task(method(:merge_path_connections)),
-              "path.magnetic_to"            => Linear::Normalizer.Task(method(:normalize_magnetic_to)),
+              "path.step.add_success_connector" => Linear::Normalizer.Task(method(:add_success_connector)),
+              "path.magnetic_to"                => Linear::Normalizer.Task(method(:normalize_magnetic_to)),
             }
           )
         end
 
-        def unary_outputs
-          {success: Activity::Output(Activity::Right, :success)}
-        end
+        SUCCESS_OUTPUT = {success: Activity::Output(Activity::Right, :success)}
 
-        def unary_connections(track_name: :success)
-          {success: [Linear::Sequence::Search.method(:Forward), track_name]}
+        def add_success_output(ctx, **)
+          ctx[:outputs] = SUCCESS_OUTPUT
         end
 
-        def merge_path_outputs(ctx, outputs: nil, **)
-          ctx[:outputs] = outputs || unary_outputs
-        end
+        def add_success_connector(ctx, track_name:, non_symbol_options:, **)
+          connectors = {Linear::Normalizer::OutputTuples.Output(:success) => Linear::Strategy.Track(track_name)}
 
-        def merge_path_connections(ctx, track_name:, connections: nil, **)
-          ctx[:connections] = connections || unary_connections(track_name: track_name)
+          ctx[:non_symbol_options] = connectors.merge(non_symbol_options)
         end
 
         def normalize_magnetic_to(ctx, track_name:, **) # TODO: merge with Railway.merge_magnetic_to
@@ -45,7 +49,6 @@ module Trailblazer
         end
 
         # This is slow and should be done only once at compile-time,
-        # DISCUSS: maybe make this a function?
         # These are the normalizers for an {Activity}, to be injected into a State.
         Normalizers = Linear::Normalizer::Normalizers.new(
           step:     Normalizer(), # here, we extend the generic FastTrack::step_normalizer with the Activity-specific DSL
@@ -56,39 +59,29 @@ module Trailblazer
 
         # DISCUSS: following methods are not part of Normalizer
 
-        def append_terminus(sequence, task, normalizers:, **options)
-          _sequence = Linear::Sequence::Builder.update_sequence_for(:terminus, task, options, normalizers: normalizers, sequence: sequence, normalizer_options: {})
-        end
-
         # @private
         def start_sequence(track_name:)
-          Linear::Strategy::DSL.start_sequence(wirings: [Linear::Sequence::Search::Forward(unary_outputs[:success], track_name)])
+          Linear::Strategy::DSL.start_sequence(wirings: [Linear::Sequence::Search::Forward(SUCCESS_OUTPUT[:success], track_name)])
         end
 
-        # Returns an initial two-step sequence with {Start.default > End.success}.
-        def initial_sequence(track_name:, end_task:, end_id:)
-          sequence = start_sequence(track_name: track_name)
-          sequence = append_terminus(sequence, end_task, id: end_id, magnetic_to: track_name, normalizers: Normalizers, append_to: "Start.default")
-        end
+        def options_for_sequence_build(track_name: :success, end_task: Activity::End.new(semantic: :success), end_id: "End.success", **)
+          initial_sequence = start_sequence(track_name: track_name)
 
-        def OptionsForSequenceBuilder(normalizers:, track_name: :success, end_task: Activity::End.new(semantic: :success), end_id: "End.success", **options)
-          # DISCUSS: instead of calling a separate {initial_sequence} method we could make DSL strategies
-          # use the actual DSL to build up the initial_sequence, somewhere outside? Maybe using {:adds}?
-          initial_sequence = initial_sequence(track_name: track_name, end_task: end_task, end_id: end_id)
-
-          {
-            sequence:               initial_sequence,
-            normalizers:            normalizers,
-            track_name:             track_name,
-            end_id:                 end_id,
-            step_interface_builder: Activity::TaskBuilder.method(:Binary), # DISCUSS: this is currently the only option we want to pass on in Path() ?
-            adds:                   [], # DISCUSS: needed?
-            **options
+          termini = [
+            [end_task, id: end_id, magnetic_to: track_name, append_to: "Start.default"]
+          ]
+
+          options = {
+            sequence:   initial_sequence,
+            track_name: track_name,
+            end_id:     end_id,           # needed in Normalizer.normalize_sequence_insert.
           }
+
+          return options, termini
         end
       end # DSL
 
-      compile_strategy!(DSL, normalizers: DSL::Normalizers) # sets :normalizer, normalizer_options, sequence and activity
+      compile_strategy!(Path::DSL, normalizers: DSL::Normalizers) # sets :normalizer, normalizer_options, sequence and activity
     end # Path
 
     def self.Path(**options, &block)
@@ -96,14 +89,3 @@ module Trailblazer
     end
   end
 end
-
-=begin
-class Operation
-  def self.subclassed(track_name:) # FIXME: it should be run in SubOperation context.
-    # initialize code here
-  end
-
-end
-
-SubOperation = Class.new(Operation, track_name: :green)
-=end

data/lib/trailblazer/activity/railway.rb

@@ -1,114 +1,112 @@
 module Trailblazer
   class Activity
     class Railway < DSL::Linear::Strategy
-
       module DSL
         Linear = Activity::DSL::Linear
 
         module_function
 
-        def Normalizer
-          path_normalizer =  Path::DSL.Normalizer()
-
-          Linear::Normalizer.prepend_to(
-            path_normalizer,
-            "activity.wirings",
-            {
-              "railway.outputs"     => Linear::Normalizer.Task(method(:normalize_path_outputs)),
-              "railway.connections" => Linear::Normalizer.Task(method(:normalize_path_connections)),
-            },
-          )
-        end
-
-        # Change some parts of the step-{Normalizer} pipeline.
-        # We're bound to using a very primitive Pipeline API, remember, we don't have
-        # a DSL at this point!
-        def NormalizerForFail
-          pipeline = Linear::Normalizer.prepend_to(
-            Normalizer(),
-            "activity.wirings",
-            {
-              "railway.magnetic_to.fail" => Linear::Normalizer.Task(Fail.method(:merge_magnetic_to)),
-            }
-          )
+        def Normalizer(prepend_to_default_outputs: [])
+          railway_output_steps = {
+            "railway.outputs" => Linear::Normalizer.Task(method(:add_failure_output)),
+          }
 
-          pipeline = Linear::Normalizer.replace(
-            pipeline,
-            "path.connections",
-            ["railway.connections.fail.success_to_failure", Linear::Normalizer.Task(Fail.method(:connect_success_to_failure))],
+          # Retrieve the base normalizer from {linear/normalizer.rb} and add processing steps.
+          step_normalizer = Path::DSL.Normalizer(
+            prepend_to_default_outputs: [railway_output_steps, *prepend_to_default_outputs]
           )
-        end
 
-        def NormalizerForPass
           Linear::Normalizer.prepend_to(
-            Normalizer(),
-            "activity.normalize_outputs_from_dsl",
-            # "path.connections",
-            {"railway.connections.pass.failure_to_success" => Linear::Normalizer.Task(Pass.method(:connect_failure_to_success))}.to_a
+            step_normalizer,
+            Path::DSL::PREPEND_TO,
+            {
+              "railway.step.add_failure_connector" => Linear::Normalizer.Task(method(:add_failure_connector)),
+            },
           )
         end
 
         module Fail
           module_function
 
+          # Change some parts of the step-{Normalizer} pipeline.
+          # We're bound to using a very primitive Pipeline API, remember, we don't have
+          # a DSL at this point!
+          def Normalizer(**options)
+            pipeline = Linear::Normalizer.prepend_to( # TODO: replace path.magnetic_to???
+              DSL.Normalizer(**options), # grab Railway::DSL::Normalizer.
+              Path::DSL::PREPEND_TO,
+              {
+                "railway.magnetic_to.fail" => Linear::Normalizer.Task(Fail.method(:merge_magnetic_to)),
+              }
+            )
+
+            pipeline = Linear::Normalizer.replace(
+              pipeline,
+              "path.step.add_success_connector",
+              ["railway.fail.success_to_failure", Linear::Normalizer.Task(Fail.method(:connect_success_to_failure))],
+            )
+          end
+
           def merge_magnetic_to(ctx, **)
             ctx[:magnetic_to] = :failure
           end
 
-          def connect_success_to_failure(ctx, connections: nil, **)
-            ctx[:connections] = connections || {success: [Linear::Sequence::Search.method(:Forward), :failure]}
+          SUCCESS_TO_FAILURE_CONNECTOR = {Linear::Normalizer::OutputTuples.Output(:success) => Linear::Strategy.Track(:failure)}
+
+          def connect_success_to_failure(ctx, non_symbol_options:, **)
+            ctx[:non_symbol_options] = SUCCESS_TO_FAILURE_CONNECTOR.merge(non_symbol_options)
           end
         end
 
         module Pass
           module_function
 
-          def connect_failure_to_success(ctx, connections:, **)
-            ctx[:connections] = connections.merge({failure: [Linear::Sequence::Search.method(:Forward), :success]})
+          def Normalizer(**options)
+            Linear::Normalizer.replace(
+              DSL.Normalizer(**options), # grab Railway::DSL::Normalizer.
+              "railway.step.add_failure_connector",
+              ["railway.pass.failure_to_success", Linear::Normalizer.Task(Pass.method(:connect_failure_to_success))]
+            )
           end
-        end
 
-        # Add {:failure} output to {:outputs}.
-        # TODO: assert that failure_outputs doesn't override existing {:outputs}
-        def normalize_path_outputs(ctx, outputs:, **)
-          outputs = failure_outputs.merge(outputs)
+          FAILURE_TO_SUCCESS_CONNECTOR = {Linear::Normalizer::OutputTuples.Output(:failure) => Linear::Strategy.Track(:success)}
 
-          ctx[:outputs] = outputs
+          def connect_failure_to_success(ctx, **options)
+            Railway::DSL.add_failure_connector(ctx, **options, failure_connector: FAILURE_TO_SUCCESS_CONNECTOR)
+          end
         end
 
-        def normalize_path_connections(ctx, connections:, **)
-          ctx[:connections] = failure_connections.merge(connections)
-        end
+        FAILURE_OUTPUT    = {failure: Activity::Output(Activity::Left, :failure)}
+        FAILURE_CONNECTOR = {Linear::Normalizer::OutputTuples.Output(:failure) => Linear::Strategy.Track(:failure)}
+        PASS_CONNECTOR    = {Linear::Normalizer::OutputTuples.Output(:failure) => Linear::Strategy.Track(:success)}
+        FAIL_CONNECTOR    = {Linear::Normalizer::OutputTuples.Output(:success) => Linear::Strategy.Track(:failure)}
 
-        def failure_outputs
-          {failure: Activity::Output(Activity::Left, :failure)}
+        # Add {:failure} output to {:outputs}.
+        # This is only called for non-Subprocess steps.
+        def add_failure_output(ctx, outputs:, **)
+          ctx[:outputs] = FAILURE_OUTPUT.merge(outputs)
         end
 
-        def failure_connections
-          {failure: [Linear::Sequence::Search.method(:Forward), :failure]}
-        end
+        def add_failure_connector(ctx, outputs:, non_symbol_options:, failure_connector: FAILURE_CONNECTOR, **)
+          return unless outputs[:failure] # do not add the default failure connection when we don't have
+                                          # a corresponding output.
 
-        def initial_sequence(failure_end:, sequence:, **path_options)
-          _seq = Path::DSL.append_terminus(sequence, failure_end, magnetic_to: :failure, id: "End.failure", normalizers: Normalizers)
+          ctx[:non_symbol_options] = failure_connector.merge(non_symbol_options)
         end
 
         Normalizers = Linear::Normalizer::Normalizers.new(
           step:  Railway::DSL.Normalizer(),
-          fail:  Railway::DSL.NormalizerForFail(),
-          pass:  Railway::DSL.NormalizerForPass(),
+          fail:  Railway::DSL::Fail.Normalizer(),
+          pass:  Railway::DSL::Pass.Normalizer(),
           terminus: Linear::Normalizer::Terminus.Normalizer(),
         )
 
-        def self.OptionsForSequenceBuilder(failure_end: Activity::End.new(semantic: :failure), **options)
-          options = Path::DSL.OptionsForSequenceBuilder(**options).
-            merge(failure_end: failure_end)
+        def options_for_sequence_build(failure_end: Activity::End.new(semantic: :failure), **options)
+          failure_terminus_options = [failure_end, magnetic_to: :failure, id: "End.failure", normalizers: Normalizers]
 
-          initial_sequence = Railway::DSL.initial_sequence(failure_end: failure_end, **options)
+          path_options, path_termini = Path::DSL.options_for_sequence_build(**options)
 
-          {
-            **options,
-            sequence: initial_sequence,
-          }
+          return path_options, path_termini + [failure_terminus_options]
         end
       end # DSL
 

data/trailblazer-activity-dsl-linear.gemspec

@@ -1,4 +1,4 @@
-lib = File.expand_path('../lib', __FILE__)
+lib = File.expand_path("../lib", __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require "trailblazer/activity/dsl/linear/version"
 
@@ -8,9 +8,9 @@ Gem::Specification.new do |spec|
   spec.authors       = ["Nick Sutterer"]
   spec.email         = ["apotonick@gmail.com"]
 
-  spec.summary       = %q(Simple DSL to define Trailblazer activities.)
-  spec.description   = %q(Simple DSL to define Trailblazer activities with arbitrary wirings.)
-  spec.homepage      = "http://trailblazer.to"
+  spec.summary       = %(Simple DSL to define Trailblazer activities.)
+  spec.description   = %(Simple DSL to define Trailblazer activities with arbitrary wirings.)
+  spec.homepage      = "https://trailblazer.to/2.1/docs/activity"
   spec.licenses      = ["LGPL-3.0"]
 
   spec.files         = `git ls-files -z`.split("\x0").reject do |f|
@@ -18,13 +18,13 @@ Gem::Specification.new do |spec|
   end
   spec.require_paths = ["lib"]
 
-  spec.add_dependency "trailblazer-activity", ">= 0.14.0", "< 0.15.0"
+  spec.add_dependency "trailblazer-activity", ">= 0.16.0", "< 0.17.0"
   spec.add_dependency "trailblazer-declarative", ">= 0.0.1", "< 0.1.0"
 
   spec.add_development_dependency "bundler"
-  spec.add_development_dependency "minitest", "~> 5.0"
+  spec.add_development_dependency "minitest", ">= 5.15.0", "< 5.16.0"
   spec.add_development_dependency "rake"
-  spec.add_development_dependency "trailblazer-developer", ">= 0.0.26"
+  spec.add_development_dependency "trailblazer-core-utils", "0.0.2"
 
-  spec.required_ruby_version = '>= 2.1.0'
+  spec.required_ruby_version = ">= 2.5.0"
 end