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

data/lib/trailblazer/activity/path.rb

@@ -1,48 +1,27 @@
 module Trailblazer
   class Activity
     # {Strategy} that helps building simple linear activities.
-    class Path
+    class Path < DSL::Linear::Strategy
       # Functions that help creating a path-specific sequence.
       module DSL
         Linear = Activity::DSL::Linear
 
         module_function
 
-        def normalizer
-          TaskWrap::Pipeline.new(normalizer_steps.to_a)
-        end
+        def Normalizer
+          # Retrieve the base normalizer from {linear/normalizer.rb} and add processing steps.
+          dsl_normalizer = Linear::Normalizer.Normalizer()
 
-        # 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]
-        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") # FIXME: where do we need you?
-          new_rows = steps.collect do |id, task|
-            Linear::Sequence.create_row(
-              task:         task,
-              magnetic_to:  :success,
-              wirings:      [Linear::Search::Forward(unary_outputs[:success], :success)],
-              id:           id,
-            )
-          end
-
-          insertion_method.(sequence, new_rows, insert_id)
+          Linear::Normalizer.prepend_to(
+            dsl_normalizer,
+            # "activity.wirings",
+            "activity.normalize_outputs_from_dsl",
+            {
+              "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)),
+            }
+          )
         end
 
         def unary_outputs
@@ -50,7 +29,7 @@ module Trailblazer
         end
 
         def unary_connections(track_name: :success)
-          {success: [Linear::Search.method(:Forward), track_name]}
+          {success: [Linear::Sequence::Search.method(:Forward), track_name]}
         end
 
         def merge_path_outputs(ctx, outputs: nil, **)
@@ -61,124 +40,70 @@ module Trailblazer
           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, end_id:, **)
-          insertion = ctx.keys & sequence_insert_options.keys
-          insertion = insertion[0]   || :before
-          target    = ctx[insertion] || end_id
-
-          insertion_method = sequence_insert_options[insertion]
-
-          ctx[:sequence_insert] = [Linear::Insert.method(insertion_method), target]
-        end
-
-        # @private
-        def sequence_insert_options
-          {
-            :before  => :Prepend,
-            :after   => :Append,
-            :replace => :Replace,
-            :delete  => :Delete,
-          }
+        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
 
-        def normalize_duplications(ctx, replace: false, **)
-          return if replace
-
-          raise_on_duplicate_id(ctx, **ctx)
-          clone_duplicate_activity(ctx, **ctx) # DISCUSS: mutates {ctx}.
-        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
+          terminus: Linear::Normalizer::Terminus.Normalizer(),
+        )
 
-        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 }
-        end
+        # pp Normalizers
 
-        def clone_duplicate_activity(ctx, task:, sequence:, **)
-          return unless task.is_a?(Class)
+        # DISCUSS: following methods are not part of Normalizer
 
-          ctx[:task] = task.clone if sequence.find { |row| row[1] == task }
+        def append_terminus(sequence, task, normalizers:, **options)
+          _sequence = Linear::Sequence::Builder.update_sequence_for(:terminus, task, options, normalizers: normalizers, sequence: sequence, normalizer_options: {})
         end
 
-        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}?
+        # @private
+        def start_sequence(track_name:)
+          Linear::Strategy::DSL.start_sequence(wirings: [Linear::Sequence::Search::Forward(unary_outputs[:success], track_name)])
         end
 
         # Returns an initial two-step sequence with {Start.default > End.success}.
         def initial_sequence(track_name:, end_task:, end_id:)
-          # TODO: this could be an Activity itself but maybe a bit too much for now.
           sequence = start_sequence(track_name: track_name)
-          sequence = append_end(sequence, task: end_task, magnetic_to: track_name, id: end_id, append_to: "Start.default")
+          sequence = append_terminus(sequence, end_task, id: end_id, magnetic_to: track_name, normalizers: Normalizers, append_to: "Start.default")
         end
 
-        def append_end(sequence, **options)
-          sequence = Linear::DSL.insert_task(sequence, **append_end_options(**options))
-        end
-
-        def append_end_options(task:, magnetic_to:, id:, append_to: "End.success")
-          end_args = {sequence_insert: [Linear::Insert.method(:Append), append_to], stop_event: true}
+        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)
 
           {
-            task:         task,
-            magnetic_to:  magnetic_to,
-            id:           id,
-            wirings:      [
-              Linear::Search::Noop(
-                Activity::Output.new(task, task.to_h[:semantic]), # DISCUSS: do we really want to transport the semantic "in" the object?
-                # magnetic_to
-              )],
-            # outputs:      {magnetic_to => },
-            # connections:  {magnetic_to => [Linear::Search.method(:Noop)]},
-            **end_args
-           }
-        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::State::Normalizer.new(
-          step:  Linear::Normalizer.activity_normalizer(Path::DSL.normalizer), # here, we extend the generic FastTrack::step_normalizer with the Activity-specific DSL
-        )
-
-        # pp Normalizers
-
-        def self.OptionsForState(normalizers: Normalizers, track_name: :success, end_task: Activity::End.new(semantic: :success), end_id: "End.success", **options)
-          initial_sequence = Path::DSL.initial_sequence(track_name: track_name, end_task: end_task, end_id: end_id) # DISCUSS: the standard initial_seq could be cached.
-
-          {
-            normalizers:      normalizers,
-            initial_sequence: initial_sequence,
-
+            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:                   [],
+            adds:                   [], # DISCUSS: needed?
             **options
           }
         end
-
-        # Implements the actual API ({#step} and friends).
-        # This can be used later to create faster DSLs where the activity is compiled only once, a la
-        #   Path() do  ... end
-        class State < Linear::State
-          def step(*args)
-            _seq = Linear::Strategy.task_for!(self, :step, *args) # mutate @state
-          end
-        end
-
       end # DSL
 
-      include DSL::Linear::Helper
-      extend DSL::Linear::Strategy
-
-      initialize!(Path::DSL::State.new(**DSL.OptionsForState()))
+      compile_strategy!(DSL, normalizers: DSL::Normalizers) # sets :normalizer, normalizer_options, sequence and activity
     end # Path
 
-    def self.Path(**options)
-      Class.new(Path) do
-        initialize!(Path::DSL::State.new(**Path::DSL.OptionsForState(**options)))
-      end
+    def self.Path(**options, &block)
+      Activity::DSL::Linear::Strategy::DSL.Build(Path, **options, &block)
     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,43 +1,50 @@
 module Trailblazer
-  # Implementation module that can be passed to `Activity[]`.
   class Activity
-    class Railway
+    class Railway < DSL::Linear::Strategy
+
       module DSL
         Linear = Activity::DSL::Linear
 
         module_function
 
-        def normalizer
-          step_options(Activity::Path::DSL.normalizer)
-        end
+        def Normalizer
+          path_normalizer =  Path::DSL.Normalizer()
 
-        # Change some parts of the "normal" {normalizer} pipeline.
-        # TODO: make this easier, even at this step.
+          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
 
-        def normalizer_for_fail
-          pipeline = TaskWrap::Pipeline.prepend(
-            normalizer,
-            "path.wirings",
+        # 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 = TaskWrap::Pipeline.prepend(
+          pipeline = Linear::Normalizer.replace(
             pipeline,
             "path.connections",
-            {
-              "railway.connections.fail.success_to_failure" => Linear::Normalizer.Task(Fail.method(:connect_success_to_failure)),
-            },
-            replace: 1 # replace {"path.connections"}
+            ["railway.connections.fail.success_to_failure", Linear::Normalizer.Task(Fail.method(:connect_success_to_failure))],
           )
         end
 
-        def normalizer_for_pass
-          pipeline = TaskWrap::Pipeline.insert_after(
-            normalizer,
-            "path.connections",
-            ["railway.connections.pass.failure_to_success", Linear::Normalizer.Task(Pass.method(:connect_failure_to_success))],
+        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
           )
         end
 
@@ -49,7 +56,7 @@ module Trailblazer
           end
 
           def connect_success_to_failure(ctx, connections: nil, **)
-            ctx[:connections] = connections || {success: [Linear::Search.method(:Forward), :failure]}
+            ctx[:connections] = connections || {success: [Linear::Sequence::Search.method(:Forward), :failure]}
           end
         end
 
@@ -57,22 +64,10 @@ module Trailblazer
           module_function
 
           def connect_failure_to_success(ctx, connections:, **)
-            ctx[:connections] = connections.merge({failure: [Linear::Search.method(:Forward), :success]})
+            ctx[:connections] = connections.merge({failure: [Linear::Sequence::Search.method(:Forward), :success]})
           end
         end
 
-        # Add {Railway} steps to normalizer path.
-        def step_options(pipeline)
-          TaskWrap::Pipeline.prepend(
-            pipeline,
-            "path.wirings",
-            {
-              "railway.outputs"     => Linear::Normalizer.Task(method(:normalize_path_outputs)),
-              "railway.connections" => Linear::Normalizer.Task(method(:normalize_path_connections)),
-            },
-          )
-        end
-
         # Add {:failure} output to {:outputs}.
         # TODO: assert that failure_outputs doesn't override existing {:outputs}
         def normalize_path_outputs(ctx, outputs:, **)
@@ -88,65 +83,50 @@ module Trailblazer
         def failure_outputs
           {failure: Activity::Output(Activity::Left, :failure)}
         end
+
         def failure_connections
-          {failure: [Linear::Search.method(:Forward), :failure]}
+          {failure: [Linear::Sequence::Search.method(:Forward), :failure]}
         end
 
-        def initial_sequence(failure_end:, initial_sequence:, **path_options)
-          # TODO: this could be an Activity itself but maybe a bit too much for now.
-          _seq = Path::DSL.append_end(initial_sequence, task: failure_end, magnetic_to: :failure, id: "End.failure")
+        def initial_sequence(failure_end:, sequence:, **path_options)
+          _seq = Path::DSL.append_terminus(sequence, failure_end, magnetic_to: :failure, id: "End.failure", normalizers: Normalizers)
         end
 
-        class State < Path::DSL::State
-          def fail(*args)
-            _seq = Linear::Strategy.task_for!(self, :fail, *args) # mutate @state
-          end
-
-          def pass(*args)
-            _seq = Linear::Strategy.task_for!(self, :pass, *args) # mutate @state
-          end
-        end # Instance
-
-        Normalizers = Linear::State::Normalizer.new(
-          step:  Linear::Normalizer.activity_normalizer( Railway::DSL.normalizer ), # here, we extend the generic FastTrack::step_normalizer with the Activity-specific DSL
-          fail:  Linear::Normalizer.activity_normalizer( Railway::DSL.normalizer_for_fail ),
-          pass:  Linear::Normalizer.activity_normalizer( Railway::DSL.normalizer_for_pass ),
+        Normalizers = Linear::Normalizer::Normalizers.new(
+          step:  Railway::DSL.Normalizer(),
+          fail:  Railway::DSL.NormalizerForFail(),
+          pass:  Railway::DSL.NormalizerForPass(),
+          terminus: Linear::Normalizer::Terminus.Normalizer(),
         )
 
-        def self.OptionsForState(normalizers: Normalizers, failure_end: Activity::End.new(semantic: :failure), **options)
-          options = Path::DSL.OptionsForState(**options).
-            merge(normalizers: normalizers, failure_end: failure_end)
+        def self.OptionsForSequenceBuilder(failure_end: Activity::End.new(semantic: :failure), **options)
+          options = Path::DSL.OptionsForSequenceBuilder(**options).
+            merge(failure_end: failure_end)
 
           initial_sequence = Railway::DSL.initial_sequence(failure_end: failure_end, **options)
 
           {
             **options,
-            initial_sequence: initial_sequence,
+            sequence: initial_sequence,
           }
         end
-
       end # DSL
 
       class << self
-        private def fail(*args, &block)
+        def fail(*args, &block)
           recompile_activity_for(:fail, *args, &block)
         end
 
-        private def pass(*args, &block)
+        def pass(*args, &block)
           recompile_activity_for(:pass, *args, &block)
         end
       end
 
-      include DSL::Linear::Helper
-      extend DSL::Linear::Strategy
-
-      initialize!(Railway::DSL::State.new(**DSL.OptionsForState()))
+      compile_strategy!(DSL, normalizers: DSL::Normalizers)
     end # Railway
 
-    def self.Railway(options)
-      Class.new(Railway) do
-        initialize!(Railway::DSL::State.new(**Railway::DSL.OptionsForState(**options)))
-      end
+    def self.Railway(**options, &block)
+      Activity::DSL::Linear::Strategy::DSL.Build(Railway, **options, &block)
     end
   end
 end

data/trailblazer-activity-dsl-linear.gemspec

@@ -19,12 +19,13 @@ Gem::Specification.new do |spec|
   end
   spec.require_paths = ["lib"]
 
-  spec.add_dependency "trailblazer-activity", ">= 0.13.0", "< 1.0.0"
+  spec.add_dependency "trailblazer-activity", ">= 0.14.0.beta1", "< 0.15.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 "rake"
-  spec.add_development_dependency "trailblazer-developer", ">= 0.0.21"
+  spec.add_development_dependency "trailblazer-developer", ">= 0.0.24"
 
   spec.required_ruby_version = '>= 2.1.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: trailblazer-activity-dsl-linear
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 1.0.0.beta1
 platform: ruby
 authors:
 - Nick Sutterer
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-12-13 00:00:00.000000000 Z
+date: 2022-07-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: trailblazer-activity
@@ -16,20 +16,40 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.13.0
+        version: 0.14.0.beta1
     - - "<"
       - !ruby/object:Gem::Version
-        version: 1.0.0
+        version: 0.15.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.13.0
+        version: 0.14.0.beta1
     - - "<"
       - !ruby/object:Gem::Version
-        version: 1.0.0
+        version: 0.15.0
+- !ruby/object:Gem::Dependency
+  name: trailblazer-declarative
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.0.1
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.0.1
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 0.1.0
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -78,14 +98,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.0.21
+        version: 0.0.24
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.0.21
+        version: 0.0.24
 description: Simple DSL to define Trailblazer activities with arbitrary wirings.
 email:
 - apotonick@gmail.com
@@ -103,12 +123,20 @@ files:
 - Rakefile
 - lib/trailblazer-activity-dsl-linear.rb
 - lib/trailblazer/activity/dsl/linear.rb
-- lib/trailblazer/activity/dsl/linear/compiler.rb
+- lib/trailblazer/activity/dsl/linear/feature/merge.rb
+- 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/helper.rb
+- lib/trailblazer/activity/dsl/linear/helper/path.rb
 - lib/trailblazer/activity/dsl/linear/normalizer.rb
-- lib/trailblazer/activity/dsl/linear/state.rb
+- lib/trailblazer/activity/dsl/linear/normalizer/terminus.rb
+- lib/trailblazer/activity/dsl/linear/sequence.rb
+- lib/trailblazer/activity/dsl/linear/sequence/builder.rb
+- lib/trailblazer/activity/dsl/linear/sequence/compiler.rb
+- lib/trailblazer/activity/dsl/linear/sequence/search.rb
 - lib/trailblazer/activity/dsl/linear/strategy.rb
-- lib/trailblazer/activity/dsl/linear/variable_mapping.rb
 - lib/trailblazer/activity/dsl/linear/version.rb
 - lib/trailblazer/activity/fast_track.rb
 - lib/trailblazer/activity/path.rb
@@ -129,9 +157,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: 2.1.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubygems_version: 3.2.3
 signing_key: 

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

@@ -1,70 +0,0 @@
-module Trailblazer
-  class Activity
-    module DSL
-      module Linear
-        # Compile a {Schema} by computing {implementations} and {intermediate} from a {Sequence}.
-        module Compiler
-          module_function
-
-          # Default strategy to find out what's a stop event is to inspect the TaskRef's {data[:stop_event]}.
-          def find_stop_task_ids(intermediate_wiring)
-            intermediate_wiring.collect { |task_ref, outs| task_ref.data[:stop_event] ? task_ref.id : nil }.compact
-          end
-
-          # The first task in the wiring is the default start task.
-          def find_start_task_ids(intermediate_wiring)
-            [intermediate_wiring.first.first.id]
-          end
-
-          def call(sequence, find_stops: method(:find_stop_task_ids), find_start: method(:find_start_task_ids))
-            _implementations, intermediate_wiring =
-              sequence.inject([[], []]) do |(implementations, intermediates), seq_row|
-                _magnetic_to, task, connections, data = seq_row
-                id = data[:id]
-
-                # execute all {Search}s for one sequence row.
-                connections = find_connections(seq_row, connections, sequence)
-
-                # FIXME: {:extensions} should be initialized
-                implementations += [[id, Schema::Implementation::Task(task, connections.collect { |output, _| output }, data[:extensions] || []) ]]
-
-                intermediates += [
-                  [
-                    Schema::Intermediate::TaskRef(id, data),
-                    # Compute outputs.
-                    connections.collect { |output, target_id| Schema::Intermediate::Out(output.semantic, target_id) }
-                  ]
-                ]
-
-                [implementations, intermediates]
-              end
-
-            start_task_ids = find_start.(intermediate_wiring)
-            stop_task_refs = find_stops.(intermediate_wiring)
-
-            intermediate   = Schema::Intermediate.new(Hash[intermediate_wiring], stop_task_refs, start_task_ids)
-            implementation = Hash[_implementations]
-
-            Schema::Intermediate.(intermediate, implementation) # implemented in the generic {trailblazer-activity} gem.
-          end
-
-          # private
-
-          def find_connections(seq_row, strategies, sequence)
-            strategies.collect do |search|
-              output, target_seq_row = search.(sequence, seq_row) # invoke the node's "connection search" strategy.
-
-              target_seq_row = sequence[-1] if target_seq_row.nil? # connect to an End if target unknown. # DISCUSS: make this configurable, maybe?
-
-              [
-                output,                                     # implementation
-                target_seq_row[3][:id],  # intermediate   # FIXME. this sucks.
-                target_seq_row # DISCUSS: needed?
-              ]
-            end.compact
-          end
-        end # Compiler
-      end
-    end
-  end
-end