trailblazer-activity-dsl-linear 1.0.0 → 1.1.0

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

@@ -71,8 +71,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
@@ -127,8 +127,47 @@ module Trailblazer
                 class_exec(&block) if block_given?
               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
+
+              return 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
           def self.copy(value, **) # DISCUSS: should that be here?
             value.copy

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.1.0"
         end
       end
     end

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

@@ -34,6 +34,7 @@ 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"
 

data/lib/trailblazer/activity/fast_track.rb

@@ -106,11 +106,6 @@ module Trailblazer
           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(),
@@ -119,16 +114,13 @@ module Trailblazer
           terminus: Linear::Normalizer::Terminus.Normalizer(),
         )
 
-        def self.OptionsForSequenceBuilder(**options)
-
-          options = Railway::DSL.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]
 
-          initial_sequence = DSL.initial_sequence(**options)
+          railway_options, railway_termini = Railway::DSL.options_for_sequence_build(**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

@@ -45,7 +45,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 +55,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)])
         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)

data/lib/trailblazer/activity/railway.rb

@@ -88,10 +88,6 @@ module Trailblazer
           {failure: [Linear::Sequence::Search.method(:Forward), :failure]}
         end
 
-        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
-
         Normalizers = Linear::Normalizer::Normalizers.new(
           step:  Railway::DSL.Normalizer(),
           fail:  Railway::DSL.NormalizerForFail(),
@@ -99,16 +95,12 @@ module Trailblazer
           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

@@ -18,13 +18,14 @@ 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.15.0", "< 0.16.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.26"
+  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'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: trailblazer-activity-dsl-linear
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors:
 - Nick Sutterer
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-08-22 00:00:00.000000000 Z
+date: 2022-12-14 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.14.0
+        version: 0.15.0
     - - "<"
       - !ruby/object:Gem::Version
-        version: 0.15.0
+        version: 0.16.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.14.0
+        version: 0.15.0
     - - "<"
       - !ruby/object:Gem::Version
-        version: 0.15.0
+        version: 0.16.0
 - !ruby/object:Gem::Dependency
   name: trailblazer-declarative
   requirement: !ruby/object:Gem::Requirement
@@ -98,14 +98,34 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.0.26
+        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.26
+        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
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.0.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.0.2
 description: Simple DSL to define Trailblazer activities with arbitrary wirings.
 email:
 - apotonick@gmail.com
@@ -114,6 +134,9 @@ 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
@@ -128,6 +151,7 @@ files:
 - 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