trailblazer-activity-dsl-linear 1.0.0 → 1.2.0

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

@@ -9,12 +9,15 @@ module Trailblazer
         #
         # They're usually invoked from {Strategy#invoke_normalizer_for!}, which is called from {Path#step},
         # {Railway#pass}, etc.
+        #
+        # Most parts of Normalizer are documented: https://trailblazer.to/2.1/docs/internals.html#internals-dsl-normalizer
         module Normalizer
           # Container for all final normalizers of a specific Strategy.
           class Normalizers
             def initialize(**options)
               @normalizers = options
             end
+
             # Execute the specific normalizer (step, fail, pass) for a particular option set provided
             # by the DSL user. Usually invoked when you call {#step}.
             def call(name, ctx)
@@ -57,21 +60,11 @@ module Trailblazer
                   [name, new_normalizer]
                 end.to_h
 
-
               Normalizers.new(**hsh.merge(new_normalizers))
             end
           end
 
-          # @private
-          class Task < TaskBuilder::Task
-            def call(wrap_ctx, flow_options={})
-              _result = call_option(@task, [wrap_ctx, flow_options]) # DISCUSS: this mutates {ctx}.
-
-              return wrap_ctx, flow_options
-            end
-          end
-
-          # Wrap user's normalizer task with {Trailblazer::Option} and thus execute it with
+          # Wrap user's normalizer task in a {Pipeline::TaskAdapter} so it executes with
           # convenient kw args.
           #
           # Example
@@ -79,87 +72,130 @@ module Trailblazer
           #
           #   # will call {normalizer_task} and pass ctx variables as kwargs, as follows
           #   def normalize_id(ctx, id: false, task:, **)
-          def Task(user_proc)
-            Normalizer::Task.new(Trailblazer::Option(user_proc), user_proc)
+          def Task(user_step)
+            Activity::TaskWrap::Pipeline::TaskAdapter.for_step(user_step, option: false) # we don't need Option as we don't have ciruit_options here, and no {:exec_context}
           end
 
           # The generic normalizer not tied to `step` or friends.
-          def Normalizer
-            pipeline = TaskWrap::Pipeline.new(
+          def Normalizer(prepend_to_default_outputs: [])
+            # Adding steps to the output pipeline means they are only called when there
+            # are no :outputs set already.
+            outputs_pipeline = TaskWrap::Pipeline.new([])
+            prepend_to_default_outputs.each do |hsh|
+              outputs_pipeline = Linear::Normalizer.prepend_to(outputs_pipeline, nil, hsh) # DISCUSS: does it matter if we prepend FastTrack to Railway, etc?
+            end
+
+            # Call the prepend_to_outputs pipeline only if {:outputs} is not set (by Subprocess).
+            # too bad we don't have nesting here, yet.
+            defaults_for_outputs = ->(ctx, args) do
+              return [ctx, args] if ctx.key?(:outputs)
+
+              outputs_pipeline.(ctx, args)
+            end
+
+            TaskWrap::Pipeline.new(
               {
-                "activity.normalize_step_interface"       => Normalizer.Task(method(:normalize_step_interface)), # Makes sure {:options} is always a hash.
+                "activity.normalize_step_interface"       => Normalizer.Task(method(:normalize_step_interface)),        # Makes sure {:options} is always a hash.
+                "activity.macro_options_with_symbol_task" => Normalizer.Task(method(:macro_options_with_symbol_task)),  # DISCUSS: we might deprecate {task: :instance_method}
+
                 "activity.merge_library_options"          => Normalizer.Task(method(:merge_library_options)),    # Merge "macro"/user options over library options.
                 "activity.normalize_for_macro"            => Normalizer.Task(method(:merge_user_options)),       # Merge user_options over "macro" options.
                 "activity.normalize_normalizer_options"   => Normalizer.Task(method(:merge_normalizer_options)), # Merge user_options over normalizer_options.
                 "activity.normalize_non_symbol_options"   => Normalizer.Task(method(:normalize_non_symbol_options)),
                 "activity.path_helper.forward_block"      => Normalizer.Task(Helper::Path::Normalizer.method(:forward_block_for_path_branch)),     # forward the "global" block
                 "activity.normalize_context"              => method(:normalize_context),
+                "activity.id_with_inherit_and_replace"    => Normalizer.Task(method(:id_with_inherit_and_replace)),
                 "activity.normalize_id"                   => Normalizer.Task(method(:normalize_id)),
-                "activity.normalize_override"             => Normalizer.Task(method(:normalize_override)),
+                "activity.normalize_override"             => Normalizer.Task(method(:normalize_override)), # TODO: remove!
                 "activity.wrap_task_with_step_interface"  => Normalizer.Task(method(:wrap_task_with_step_interface)),
 
-                "activity.inherit_option"                 => Normalizer.Task(method(:inherit_option)),
+                # Nested pipeline:
+                "activity.default_outputs"                => defaults_for_outputs, # only {if :outputs.nil?}
+
+                "extensions.convert_extensions_option_to_tuples" => Normalizer.Task(Extensions.method(:convert_extensions_option_to_tuples)),
+
+                "inherit.recall_recorded_options"         => Normalizer.Task(Inherit.method(:recall_recorded_options)),
                 "activity.sequence_insert"                => Normalizer.Task(method(:normalize_sequence_insert)),
                 "activity.normalize_duplications"         => Normalizer.Task(method(:normalize_duplications)),
 
-                "activity.path_helper.path_to_track"       => Normalizer.Task(Helper::Path::Normalizer.method(:convert_paths_to_tracks)),
-                "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.path_helper.path_to_track"      => Normalizer.Task(Helper::Path::Normalizer.method(:convert_paths_to_tracks)),
+
+
+                "output_tuples.normalize_output_tuples"           => Normalizer.Task(OutputTuples.method(:normalize_output_tuples)),     # Output(Signal, :semantic) => Id()
+                "output_tuples.remember_custom_output_tuples"     => Normalizer.Task(OutputTuples.method(:remember_custom_output_tuples)),     # Output(Signal, :semantic) => Id()
+                "output_tuples.register_additional_outputs"       => Normalizer.Task(OutputTuples.method(:register_additional_outputs)),     # Output(Signal, :semantic) => Id()
+                "output_tuples.filter_inherited_output_tuples"    => Normalizer.Task(OutputTuples.method(:filter_inherited_output_tuples)),
+
+                "activity.wirings"                        => Normalizer.Task(OutputTuples::Connections.method(:compile_wirings)),
 
-                "activity.wirings"                            => Normalizer.Task(method(:compile_wirings)),
+
+                "extensions.compile_extensions"           => Normalizer.Task(Extensions.method(:compile_extensions)),
+                "extensions.compile_recorded_extensions"  => Normalizer.Task(Extensions.method(:compile_recorded_extensions)),
+
+                # DISCUSS: make this configurable? maybe lots of folks don't want {:inherit}?
+                "inherit.compile_recorded_options"        => Normalizer.Task(Inherit.method(:compile_recorded_options)),
 
                 # TODO: make this a "Subprocess":
                 "activity.compile_data" => Normalizer.Task(method(:compile_data)),
                 "activity.create_row" => Normalizer.Task(method(:create_row)),
                 "activity.create_add" => Normalizer.Task(method(:create_add)),
                 "activity.create_adds" => Normalizer.Task(method(:create_adds)),
-              }.
-                collect { |id, task| TaskWrap::Pipeline.Row(id, task) }
+              }
+                .collect { |id, task| TaskWrap::Pipeline.Row(id, task) }
             )
+          end
+
+          # DISCUSS: should we remove this special case?
+          # This handles
+          #   step task: :instance_method_exposing_circuit_interface
+          def macro_options_with_symbol_task(ctx, options:, **)
+            return if options[:wrap_task]
+            return unless options[:task].is_a?(Symbol)
 
-            pipeline
+            ctx[:options] = {
+              **options,
+              wrap_task:              true,
+              step_interface_builder: ->(task) { Trailblazer::Option(task) } # only wrap in Option, not {TaskAdapter}.
+            }
           end
 
+          # @param {:options} The first argument passed to {#step}
+          # After this step, options is always a hash.
+          #
           # 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, options:, **)
-            options = case options
-                      when Hash
-                        # Circuit Interface
-                        task  = options.fetch(:task)
-                        id    = options[:id]
-
-                        if task.is_a?(Symbol)
-                          # step task: :find, id: :load
-                          { **options, id: (id || task), task: Trailblazer::Option(task) }
-                        else
-                          # step task: Callable, ... (Subprocess, Proc, macros etc)
-                          options # NOOP
-                        end
-                      else
-                        # Step Interface
-                        # step :find, ...
-                        # step Callable, ... (Method, Proc etc)
-                        { task: options, wrap_task: true }
-                      end
-
-            ctx[:options] = options
+            return if options.is_a?(Hash)
+
+            # Step Interface
+            # step :find, ...
+            # step Callable, ... (Method, Proc etc)
+            ctx[:options] = {
+              task:       options,
+              wrap_task:  true # task exposes step interface.
+            }
           end
 
-          def wrap_task_with_step_interface(ctx, wrap_task: false, step_interface_builder:, task:, **)
+          # @param :wrap_task If true, the {:task} is wrapped using the step_interface_builder, meaning the
+          #                   task is expecting the step interface.
+          def wrap_task_with_step_interface(ctx, step_interface_builder:, task:, wrap_task: false, **)
             return unless wrap_task
 
             ctx[:task] = step_interface_builder.(task)
           end
 
-          def normalize_id(ctx, id: false, task:, **)
+          def normalize_id(ctx, task:, id: false, **)
             ctx[:id] = id || task
           end
 
+          # TODO: remove {#normalize_override} in 1.2.0 (Used in macro-contract tests).
           # {:override} really only makes sense for {step Macro(), {override: true}} where the {user_options}
           # dictate the overriding.
           def normalize_override(ctx, id:, override: false, **)
             return unless override
+
+            Activity::Deprecate.warn Linear::Deprecate.dsl_caller_location, "The :override option is deprecated and will be removed. Please use :replace instead."
+
             ctx[:replace] = (id || raise)
           end
 
@@ -185,20 +221,6 @@ module Trailblazer
             return ctx, flow_options
           end
 
-          # Compile the actual {Seq::Row}'s {wiring}.
-          # This combines {:connections} and {:outputs}
-          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 #{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
-          end
-
           # Processes {:before,:after,:replace,:delete} options and
           # defaults to {before: "End.success"} which, yeah.
           def normalize_sequence_insert(ctx, end_id:, **)
@@ -214,10 +236,10 @@ module Trailblazer
           # @private
           def sequence_insert_options
             {
-              :before  => :Prepend,
-              :after   => :Append,
-              :replace => :Replace,
-              :delete  => :Delete,
+              before:   :Prepend,
+              after:    :Append,
+              replace:  :Replace,
+              delete:   :Delete
             }
           end
 
@@ -240,7 +262,6 @@ module Trailblazer
             ctx[:task] = task.clone if sequence.find { |row| row[1] == task }
           end
 
-
           # 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.
@@ -252,97 +273,14 @@ module Trailblazer
             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:, sequence:, normalizers:, **)
-            # Find all {Output() => Track()/Id()/End()}
-            output_configs = non_symbol_options.find_all{ |k,v| k.kind_of?(Linear::OutputSemantic) }
-            return unless output_configs.any?
-
-            # DISCUSS: how could we add another magnetic_to to an end?
-            output_configs.each do |output, cfg|
-              new_connections, add =
-                if cfg.is_a?(Linear::Track)
-                  [output_to_track(ctx, output, cfg), cfg.adds] # FIXME: why does Track have a {adds} field? we don't use it anywhere.
-                elsif cfg.is_a?(Linear::Id)
-                  [output_to_id(ctx, output, cfg.value), []]
-                elsif cfg.is_a?(Activity::End)
-                  end_id     = Activity::Railway.end_id(**cfg.to_h)
-                  end_exists = Activity::Adds::Insert.find_index(ctx[:sequence], end_id)
-
-                  _adds = end_exists ? [] : add_terminus(cfg, id: end_id, sequence: sequence, normalizers: normalizers)
-
-                  [output_to_id(ctx, output, end_id), _adds]
-                else
-                  raise cfg.inspect
-                end
-
-              connections = connections.merge(new_connections)
-              adds += add
-            end
-
-            ctx[:connections] = connections
-            ctx[:adds]        = adds
-          end
-
-          def output_to_track(ctx, output, track)
-            search_strategy = track.options[:wrap_around] ? :WrapAround : :Forward
-
-            {output.value => [Linear::Sequence::Search.method(search_strategy), track.color]}
-          end
+          # Whenever {:replace} and {:inherit} are passed, automatically assign {:id}.
+          # DISCUSS: this step could be nested in {inherit_option}.
+          def id_with_inherit_and_replace(ctx, id: nil, replace: nil, inherit: nil, **)
+            return if id
+            return unless inherit # inherit: true and inherit: [] both work.
+            return unless replace
 
-          def output_to_id(ctx, output, target)
-            {output.value => [Linear::Sequence::Search.method(:ById), target]}
-          end
-
-          # Returns ADDS for the new terminus.
-          def add_terminus(end_event, id:, sequence:, normalizers:)
-            step_options = Linear::Sequence::Builder.invoke_normalizer_for(:terminus, end_event, {id: id}, sequence: sequence, normalizer_options: {}, normalizers: normalizers)
-
-            step_options[:adds]
-          end
-
-          # Output(Signal, :semantic) => Id()
-          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?
-
-            dsl_options = {}
-
-            output_configs.collect do |output, cfg| # {cfg} = Track(:success)
-              outputs     = outputs.merge(output.semantic => output)
-              dsl_options = dsl_options.merge(Linear::Strategy.Output(output.semantic) => cfg)
-            end
-
-            ctx[:outputs]            = outputs
-            ctx[:non_symbol_options] = non_symbol_options.merge(dsl_options)
-          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, inherit: false, sequence:, id:, extensions: [], **)
-            return unless inherit === true
-
-            row = InheritOption.find_row(sequence, id) # from this row we're inheriting options.
-
-            inherited_connections = row.data[:connections]
-            inherited_extensions  = row.data[:extensions]
-
-            ctx[:connections] = get_inheritable_connections(ctx, inherited_connections)
-            ctx[:extensions]  = Array(inherited_extensions) + Array(extensions)
-          end
-
-          module InheritOption # TODO: move all inherit methods in here!
-            def self.find_row(sequence, id)
-              index = Activity::Adds::Insert.find_index(sequence, id)
-              sequence[index]
-            end
-          end
-
-          # return connections from {parent} step which are supported by current step
-          private def get_inheritable_connections(ctx, parent_connections)
-            return parent_connections unless ctx[:outputs]
-
-            parent_connections.slice(*ctx[:outputs].keys)
+            ctx[:id] = replace
           end
 
           def create_row(ctx, task:, wirings:, magnetic_to:, data:, **)
@@ -359,13 +297,14 @@ module Trailblazer
 
           # TODO: document DataVariable() => :name
           # Compile data that goes into the sequence row.
-          def compile_data(ctx, default_variables_for_data: [:id, :dsl_track, :connections, :extensions, :stop_event], non_symbol_options:, **)
-            variables_for_data = non_symbol_options.find_all { |k,v| k.instance_of?(Linear::DataVariableName) }.collect { |k,v| Array(v) }.flatten
+          def compile_data(ctx, non_symbol_options:, default_variables_for_data: [:id, :dsl_track, :extensions], **)
+            variables_for_data = non_symbol_options
+              .find_all { |k, v| k.instance_of?(Linear::DataVariableName) }
+              .flat_map { |k, v| Array(v) }
 
             ctx[:data] = (default_variables_for_data + variables_for_data).collect { |key| [key, ctx[key]] }.to_h
           end
         end
-
       end # Normalizer
     end
   end

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

@@ -13,7 +13,7 @@ module Trailblazer
             # @private
             # Run a specific normalizer (e.g. for `#step`), apply the adds to the sequence and return the latter.
             # DISCUSS: where does this method belong? Sequence + Normalizers?
-            def self.update_sequence_for(type, task, options={}, sequence:, **kws, &block)
+            def self.update_sequence_for(type, task, options = {}, sequence:, **kws, &block)
               step_options = invoke_normalizer_for(type, task, options, sequence: sequence, **kws, &block)
 
               _sequence = Activity::Adds.apply_adds(sequence, step_options[:adds])
@@ -32,7 +32,8 @@ module Trailblazer
                 sequence:    sequence,
               }
 
-              _step_options = normalizers.(type,
+              _step_options = normalizers.(
+                type,
                 normalizer_options: normalizer_options, # class-level Strategy configuration, such as :step_interface_builder
                 options:            task,               # macro-options
                 user_options:       options,            # user-specified options from the DSL method

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

@@ -8,16 +8,19 @@ module Trailblazer
             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
+            def find_termini(intermediate_wiring)
+              intermediate_wiring
+                .find_all { |task_ref, _| task_ref.data[:stop_event] }
+                .collect  { |task_ref, _| [task_ref.id, task_ref.data.fetch(:semantic)] }
+                .to_h
             end
 
             # The first task in the wiring is the default start task.
-            def find_start_task_ids(intermediate_wiring)
-              [intermediate_wiring.first.first.id]
+            def find_start_task_id(intermediate_wiring) # FIXME: shouldn't we use sequence here? and Row#id?
+              intermediate_wiring.first.first.id
             end
 
-            def call(sequence, find_stops: method(:find_stop_task_ids), find_start: method(:find_start_task_ids))
+            def call(sequence, find_stops: method(:find_termini), find_start: method(:find_start_task_id))
               _implementations, intermediate_wiring =
                 sequence.inject([[], []]) do |(implementations, intermediates), seq_row|
                   _magnetic_to, task, connections, data = seq_row
@@ -27,7 +30,7 @@ module Trailblazer
                   connections = find_connections(seq_row, connections, sequence)
 
                   # FIXME: {:extensions} should be initialized
-                  implementations += [[id, Schema::Implementation::Task(task, connections.collect { |output, _| output }, data[:extensions] || []) ]]
+                  implementations += [[id, Schema::Implementation::Task(task, connections.collect { |output, _| output }, data[:extensions] || [])]]
 
                   intermediates += [
                     [
@@ -40,29 +43,30 @@ module Trailblazer
                   [implementations, intermediates]
                 end
 
-              start_task_ids = find_start.(intermediate_wiring)
-              stop_task_refs = find_stops.(intermediate_wiring)
+              start_task_id         = find_start.(intermediate_wiring)
+              terminus_to_semantic  = find_stops.(intermediate_wiring)
 
-              intermediate   = Schema::Intermediate.new(Hash[intermediate_wiring], stop_task_refs, start_task_ids)
-              implementation = Hash[_implementations]
+              intermediate   = Schema::Intermediate.new(intermediate_wiring.to_h, terminus_to_semantic, start_task_id)
+              implementation = _implementations.to_h
 
-              Schema::Intermediate.(intermediate, implementation) # implemented in the generic {trailblazer-activity} gem.
+              Schema::Intermediate::Compiler.(intermediate, implementation) # implemented in the generic {trailblazer-activity} gem.
             end
 
             # private
 
-            def find_connections(seq_row, strategies, sequence)
-              strategies.collect do |search|
+            # Execute all search strategies for a row, retrieve outputs and
+            # their respective target IDs.
+            def find_connections(seq_row, searches, sequence)
+              searches.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?
+                  output,
+                  target_seq_row.id
                 ]
-              end.compact
+              end
             end
           end # Compiler
         end # Sequence

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

@@ -11,7 +11,7 @@ class Trailblazer::Activity
           # Note that we only go forward, no back-references are done here.
           def Forward(output, target_color)
             ->(sequence, me) do
-              target_seq_row = find_in_range(sequence[sequence.index(me)+1..-1], target_color)
+              target_seq_row = find_in_range(sequence[sequence.index(me) + 1..-1], target_color)
 
               return output, target_seq_row
             end
@@ -23,7 +23,7 @@ class Trailblazer::Activity
             ->(sequence, me) do
               my_index      = sequence.index(me)
               # First, try all elements after me, then go through the elements preceding myself.
-              wrapped_range = sequence[my_index+1..-1] + sequence[0..my_index-1]
+              wrapped_range = sequence[my_index + 1..-1] + sequence[0..my_index - 1]
 
               target_seq_row = find_in_range(wrapped_range, target_color)
 
@@ -31,12 +31,6 @@ class Trailblazer::Activity
             end
           end
 
-          def Noop(output)
-            ->(sequence, me) do
-              return output, [nil,nil,nil,{}] # FIXME
-            end
-          end
-
           # Find the seq_row with {id} and connect the current node to it.
           def ById(output, id)
             ->(sequence, me) do

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

@@ -28,10 +28,15 @@ module Trailblazer
             end
 
             # @public
-              # We forward `step` to the Dsl (State) object.
-              # Recompiling the activity/sequence is a matter specific to Strategy (Railway etc).
-            def step(*args, &block); recompile_activity_for(:step, *args, &block); end
-            def terminus(*args);     recompile_activity_for(:terminus, *args); end
+            # We forward `step` to the Dsl (State) object.
+            # Recompiling the activity/sequence is a matter specific to Strategy (Railway etc).
+            def step(*args, &block)
+              recompile_activity_for(:step, *args, &block)
+            end
+
+            def terminus(*args)
+              recompile_activity_for(:terminus, *args)
+            end
 
             private def recompile_activity_for(type, *args, &block)
               sequence = apply_step_on_sequence_builder(type, *args, &block)
@@ -41,16 +46,14 @@ module Trailblazer
 
             # TODO: make {rescue} optional, only in dev mode.
             # @return Sequence
-            private def apply_step_on_sequence_builder(type, arg, options={}, &block)
-              return Sequence::Builder.(type, arg, options,
+            private def apply_step_on_sequence_builder(type, arg, options = {}, &block)
+              Sequence::Builder.(type, arg, options,
                 sequence:           @state.get(:sequence),
                 normalizers:        @state.get(:normalizers),
 
                 normalizer_options: @state.get(:normalizer_options),
 
-                 &block
-              )
-
+                &block)
             rescue Activity::Adds::IndexError
               # re-raise this exception with activity class prepended
               # to the message this time.
@@ -71,8 +74,8 @@ module Trailblazer
             end
 
             # Used only once per strategy class body.
-            def compile_strategy!(strategy, **options)
-              options = strategy.OptionsForSequenceBuilder(**options)
+            def compile_strategy!(strategy_dsl, **options)
+              options = DSL.OptionsForSequenceBuilder(strategy_dsl, **options)
 
               compile_strategy_for!(**options)
             end
@@ -90,7 +93,7 @@ module Trailblazer
 
               activity.to_h.to_h.merge(
                 activity: activity,
-                sequence: @state.get(:sequence),
+                sequence: @state.get(:sequence)
               )
             end
 
@@ -105,8 +108,8 @@ module Trailblazer
               )
             end
 
-            def invoke(*args)
-              TaskWrap.invoke(self, *args)
+            def invoke(*args, **kws)
+              TaskWrap.invoke(self, *args, **kws)
             end
           end # class << self
           # FIXME: do we want class << self?!
@@ -124,9 +127,47 @@ module Trailblazer
               Class.new(strategy) do
                 compile_strategy!(strategy::DSL, normalizers: @state.get(:normalizers), **options)
 
-                class_exec(&block) if block_given?
+                class_exec(&block) if block
               end
             end
+
+            def OptionsForSequenceBuilder(strategy_dsl, termini: nil, **user_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}?
+              strategy_options, strategy_termini = strategy_dsl.options_for_sequence_build(**user_options) # call Path.options_for_sequence_builder
+
+              # DISCUSS: passing on Normalizers here is a service, not sure I like it.
+              initial_sequence = process_termini(strategy_options[:sequence], termini || strategy_termini, normalizers: strategy_dsl::Normalizers)
+
+              {
+                step_interface_builder: method(:build_circuit_task_for_step),
+                adds:                   [], # DISCUSS: needed?
+                **user_options,
+                **strategy_options, # this might (and should!) override :track_name etc.
+                sequence:               initial_sequence,
+              }
+              # no {:termini} left in options
+            end
+
+            # If no {:termini} were provided by the Strategy user, we use the default
+            # {strategy_termini}.
+            def process_termini(sequence, termini, **options_for_append_terminus)
+              termini.each do |task, terminus_options|
+                sequence = append_terminus(sequence, task, **options_for_append_terminus, **terminus_options)
+              end
+
+              sequence
+            end
+
+            def append_terminus(sequence, task, normalizers:, **options)
+              # DISCUSS: why are we requiring {:normalizers} here? only for invoking Normalizer.terminus
+              _sequence = Linear::Sequence::Builder.update_sequence_for(:terminus, task, options, normalizers: normalizers, sequence: sequence, normalizer_options: {})
+            end
+
+            # Wraps {user_step} into a circuit-interface compatible callable, a.k.a. "task".
+            def build_circuit_task_for_step(user_step)
+              Activity::Circuit::TaskAdapter.for_step(user_step, option: true)
+            end
           end # DSL
 
           # FIXME: move to State#dup
@@ -156,5 +197,3 @@ module Trailblazer
     end
   end
 end
-
-

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

@@ -3,7 +3,7 @@ module Trailblazer
     module Activity
       module DSL
         module Linear
-          VERSION = "1.0.0"
+          VERSION = "1.2.0"
         end
       end
     end