trailblazer-activity-dsl-linear 1.1.0 → 1.2.0

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,36 +134,20 @@ 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
 
         # 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(),
         )
 

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
@@ -57,7 +61,7 @@ module Trailblazer
 
         # @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
 
         def options_for_sequence_build(track_name: :success, end_task: Activity::End.new(semantic: :success), end_id: "End.success", **)
@@ -85,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,97 +1,103 @@
 module Trailblazer
   class Activity
     class Railway < DSL::Linear::Strategy
-
       module DSL
         Linear = Activity::DSL::Linear
 
         module_function
 
-        def Normalizer
-          path_normalizer =  Path::DSL.Normalizer()
+        def Normalizer(prepend_to_default_outputs: [])
+          railway_output_steps = {
+            "railway.outputs" => Linear::Normalizer.Task(method(:add_failure_output)),
+          }
 
-          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)),
-            },
+          # 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
-
-        # 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)),
-            }
-          )
-
-          pipeline = Linear::Normalizer.replace(
-            pipeline,
-            "path.connections",
-            ["railway.connections.fail.success_to_failure", Linear::Normalizer.Task(Fail.method(:connect_success_to_failure))],
-          )
-        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]}
+        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.
+
+          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(),
         )
 

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,14 +18,13 @@ Gem::Specification.new do |spec|
   end
   spec.require_paths = ["lib"]
 
-  spec.add_dependency "trailblazer-activity", ">= 0.15.0", "< 0.16.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.27", "< 0.1.0"
   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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: trailblazer-activity-dsl-linear
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.2.0
 platform: ruby
 authors:
 - Nick Sutterer
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-12-14 00:00:00.000000000 Z
+date: 2023-03-02 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.15.0
+        version: 0.16.0
     - - "<"
       - !ruby/object:Gem::Version
-        version: 0.16.0
+        version: 0.17.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.15.0
+        version: 0.16.0
     - - "<"
       - !ruby/object:Gem::Version
-        version: 0.16.0
+        version: 0.17.0
 - !ruby/object:Gem::Dependency
   name: trailblazer-declarative
   requirement: !ruby/object:Gem::Requirement
@@ -68,16 +68,22 @@ dependencies:
   name: minitest
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.15.0
+    - - "<"
       - !ruby/object:Gem::Version
-        version: '5.0'
+        version: 5.16.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.15.0
+    - - "<"
       - !ruby/object:Gem::Version
-        version: '5.0'
+        version: 5.16.0
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -92,26 +98,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: trailblazer-developer
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 0.0.27
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: 0.1.0
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 0.0.27
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: 0.1.0
 - !ruby/object:Gem::Dependency
   name: trailblazer-core-utils
   requirement: !ruby/object:Gem::Requirement
@@ -134,9 +120,6 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".github/workflows/ci.yml"
-- ".github/workflows/ci_jruby.yml"
-- ".github/workflows/ci_legacy.yml"
-- ".github/workflows/ci_truffleruby.yml"
 - ".gitignore"
 - CHANGES.md
 - DSL_IDEAS
@@ -150,11 +133,13 @@ files:
 - lib/trailblazer/activity/dsl/linear/feature/patch.rb
 - lib/trailblazer/activity/dsl/linear/feature/variable_mapping.rb
 - lib/trailblazer/activity/dsl/linear/feature/variable_mapping/dsl.rb
-- lib/trailblazer/activity/dsl/linear/feature/variable_mapping/inherit.rb
 - lib/trailblazer/activity/dsl/linear/feature/variable_mapping/runtime.rb
 - lib/trailblazer/activity/dsl/linear/helper.rb
 - lib/trailblazer/activity/dsl/linear/helper/path.rb
 - lib/trailblazer/activity/dsl/linear/normalizer.rb
+- lib/trailblazer/activity/dsl/linear/normalizer/extensions.rb
+- lib/trailblazer/activity/dsl/linear/normalizer/inherit.rb
+- lib/trailblazer/activity/dsl/linear/normalizer/output_tuples.rb
 - lib/trailblazer/activity/dsl/linear/normalizer/terminus.rb
 - lib/trailblazer/activity/dsl/linear/sequence.rb
 - lib/trailblazer/activity/dsl/linear/sequence/builder.rb
@@ -166,7 +151,7 @@ files:
 - lib/trailblazer/activity/path.rb
 - lib/trailblazer/activity/railway.rb
 - trailblazer-activity-dsl-linear.gemspec
-homepage: http://trailblazer.to
+homepage: https://trailblazer.to/2.1/docs/activity
 licenses:
 - LGPL-3.0
 metadata: {}
@@ -178,7 +163,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.1.0
+      version: 2.5.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="

data/.github/workflows/ci_jruby.yml

@@ -1,19 +0,0 @@
-## This file is managed by Terraform.
-## Do not modify this file directly, as it may be overwritten.
-## Please open an issue instead.
-name: CI JRuby
-on: [push, pull_request]
-jobs:
-  test:
-    strategy:
-      fail-fast: false
-      matrix:
-        ruby: [jruby, jruby-head]
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@v3
-    - uses: ruby/setup-ruby@v1
-      with:
-        ruby-version: ${{ matrix.ruby }}
-        bundler-cache: true
-    - run: bundle exec rake

data/.github/workflows/ci_legacy.yml

@@ -1,19 +0,0 @@
-## This file is managed by Terraform.
-## Do not modify this file directly, as it may be overwritten.
-## Please open an issue instead.
-name: CI with EOL ruby versions
-on: [push, pull_request]
-jobs:
-  test:
-    strategy:
-      fail-fast: false
-      matrix:
-        ruby: [2.5, 2.6]
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@v3
-    - uses: ruby/setup-ruby@v1
-      with:
-        ruby-version: ${{ matrix.ruby }}
-        bundler-cache: true
-    - run: bundle exec rake