trailblazer-activity-dsl-linear 0.2.7 → 0.2.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f6c778b5c85e44e0bada5fd6b073bca7c5ad859dd7e7670970ded5828253f12f
-  data.tar.gz: 016efb08c0817d3075ec0d504ceaf00a79cd69021b0db2a3b00445592a04e6b9
+  metadata.gz: f2dd213289e88821986b93fc8421474654537f47cee570eb1d3b14e8a6b22020
+  data.tar.gz: 8e64b5daeec8cf1781c4e0411b9bba9a482bdd66a52509281996615ec55eb708
 SHA512:
-  metadata.gz: 6a4781c4a6edb5d16078cd48be9379d862be9d13c6f62ba849b86fe872c33411541456bba91ed64ae96125b9526053976a77910ddcaae68e92227391378a7d83
-  data.tar.gz: 9bcd652ff1be61710625ab18fb20af9e765f49be8f02e940b6b3ebab2a43e679fb0299a9faa354501229c6f411fd76a3698db4ea29404ae15baf9b5693eb338e
+  metadata.gz: 3a8bece3d93808c8267f18200dbb55556f8916d6f0071a5d53f33a462fc34c0d9084c0a1d4ffcef084f459bf738e08b7f358ff189d4e86f3abd716aaa688f611
+  data.tar.gz: d6758434610eeb29d00f31744e250b26d4258364d17aaefaf6ea8e3355040a27b7b8adc453514272d076e53aeb313ec7af56573ff57b99e136e6b8941a7bde3a

data/CHANGES.md

@@ -1,3 +1,8 @@
+# 0.2.8
+
+* Add `Track(:color, wrap_around: true)` option and `Search::WrapAround` so you can find a certain track color (or the beginning of a Path) even when the path was positioned before the actual step in the `Sequence`.
+* Add `:inherit` option so `step` can override an existing step while inheriting the original `:extensions` and `:connections` (which are the `Outputs`). This is great to customize "template" activities.
+
 # 0.2.7
 
 * `Did you mean ?` suggestions on Linear::Sequence::IndexError.

data/Gemfile

@@ -10,3 +10,4 @@ gem "rubocop", require: false
 # gem "trailblazer-context", path: "../trailblazer-context"
 # gem "trailblazer-developer", path: "../trailblazer-developer"
 # gem "trailblazer-activity", path: "../trailblazer-activity"
+# gem "trailblazer-activity", path: "../circuit"

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

@@ -58,7 +58,21 @@ 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 = sequence[sequence.index(me)+1..-1].find { |seq_row| seq_row[0] == target_color }
+            target_seq_row = find_in_range(sequence[sequence.index(me)+1..-1], target_color)
+
+            return output, target_seq_row
+          end
+        end
+
+        # Tries to find a track colored step by doing a Forward-search, first, then wraps around going
+        # through all steps from sequence start to self.
+        def WrapAround(output, target_color)
+          ->(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]
+
+            target_seq_row = find_in_range(wrapped_range, target_color)
 
             return output, target_seq_row
           end
@@ -79,6 +93,11 @@ class Trailblazer::Activity
             return output, target_seq_row
           end
         end
+
+        # @private
+        def find_in_range(range, target_color)
+          target_seq_row = range.find { |seq_row| seq_row[0] == target_color }
+        end
       end # Search
 
       # Sequence

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

@@ -6,7 +6,7 @@ module Trailblazer
           # @api private
           OutputSemantic = Struct.new(:value)
           Id             = Struct.new(:value)
-          Track          = Struct.new(:color, :adds)
+          Track          = Struct.new(:color, :adds, :options)
           Extension      = Struct.new(:callable) do
             def call(*args, &block)
               callable.(*args, &block)
@@ -35,8 +35,8 @@ module Trailblazer
               "End.#{_end.to_h[:semantic]}" # TODO: use everywhere
             end
 
-            def Track(color)
-              Track.new(color, []).freeze
+            def Track(color, wrap_around: false)
+              Track.new(color, [], wrap_around: wrap_around).freeze
             end
 
             def Id(id)
@@ -81,7 +81,7 @@ module Trailblazer
               end
 
               # Connect the Output() => Track(path_track)
-              return Track.new(track_color, adds)
+              return Track.new(track_color, adds, {})
             end
 
             # Computes the {:outputs} options for {activity}.

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

@@ -20,6 +20,7 @@ module Trailblazer
               "activity.normalize_id"                   => method(:normalize_id),
               "activity.normalize_override"             => method(:normalize_override),
               "activity.wrap_task_with_step_interface"  => method(:wrap_task_with_step_interface), # last
+              "activity.inherit_option"               => method(:inherit_option),
               },
 
               Linear::Insert.method(:Append), "Start.default"
@@ -128,7 +129,7 @@ module Trailblazer
 
             ctx[:wirings] =
               connections.collect do |semantic, (search_strategy_builder, *search_args)|
-                output = outputs[semantic] || raise("No `#{semantic}` output found for #{outputs.inspect}")
+                output = outputs[semantic] || raise("No `#{semantic}` output found for #{ctx[:id].inspect} and outputs #{outputs.inspect}")
 
                 search_strategy_builder.( # return proc to be called when compiling Seq, e.g. {ById(output, :id)}
                   output,
@@ -176,8 +177,10 @@ module Trailblazer
             return Trailblazer::Activity::Right, [new_ctx, flow_options]
           end
 
-          def output_to_track(ctx, output, target)
-            {output.value => [Linear::Search.method(:Forward), target.color]}
+          def output_to_track(ctx, output, track)
+            search_strategy = track.options[:wrap_around] ? :WrapAround : :Forward
+
+            {output.value => [Linear::Search.method(search_strategy), track.color]}
           end
 
           def output_to_id(ctx, output, target)
@@ -227,9 +230,28 @@ module Trailblazer
             return Trailblazer::Activity::Right, [ctx.merge(new_ctx), flow_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, flow_options), *)
+            return Trailblazer::Activity::Right, [ctx, flow_options] unless ctx[:inherit]
+
+            sequence = ctx[:sequence]
+            id = ctx[:id]
+
+            index = Linear::Insert.find_index(sequence, id)
+            row   = sequence[index] # from this row we're inheriting options.
+
+            extensions = (row[3][:extensions]||[]) + (ctx[:extensions]||[]) # FIXME: DEFAULTING, FOR FUCK'S SAKE
+
+            ctx = ctx.merge(connections: row[3][:connections], extensions: extensions) # "inherit"
+
+            return Trailblazer::Activity::Right, [ctx, flow_options]
+          end
+
           # TODO: make this extendable!
           def cleanup_options((ctx, flow_options), *)
-            new_ctx = ctx.reject { |k, v| [:connections, :outputs, :end_id, :step_interface_builder, :failure_end, :track_name, :sequence].include?(k) }
+            # new_ctx = ctx.reject { |k, v| [:connections, :outputs, :end_id, :step_interface_builder, :failure_end, :track_name, :sequence].include?(k) }
+            new_ctx = ctx.reject { |k, v| [:outputs, :end_id, :step_interface_builder, :failure_end, :track_name, :sequence].include?(k) }
 
             return Trailblazer::Activity::Right, [new_ctx, flow_options]
           end

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

@@ -3,7 +3,7 @@ module Trailblazer
     module Activity
       module DSL
         module Linear
-          VERSION = "0.2.7"
+          VERSION = "0.2.8"
         end
       end
     end

data/lib/trailblazer/activity/railway.rb

@@ -90,6 +90,8 @@ module Trailblazer
           )
         end
 
+        # Add {:failure} output to {:outputs}.
+        # TODO: assert that failure_outputs doesn't override existing {:outputs}
         def normalize_path_outputs((ctx, flow_options), *)
           outputs = failure_outputs.merge(ctx[:outputs])
           ctx     = ctx.merge(outputs: outputs)
@@ -132,7 +134,6 @@ module Trailblazer
           pass:  Linear::Normalizer.activity_normalizer( Railway::DSL.normalizer_for_pass ),
         )
 
-
         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)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: trailblazer-activity-dsl-linear
 version: !ruby/object:Gem::Version
-  version: 0.2.7
+  version: 0.2.8
 platform: ruby
 authors:
 - Nick Sutterer
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-05-22 00:00:00.000000000 Z
+date: 2020-06-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: trailblazer-activity
@@ -135,7 +135,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.8
+rubyforge_project: 
+rubygems_version: 2.7.6
 signing_key: 
 specification_version: 4
 summary: Simple DSL to define Trailblazer activities.