trailblazer-activity-dsl-linear 0.2.6 → 0.2.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 74aa92e841b1cec015946ecabf0a7dde756df34adf30820db522223be3452870
-  data.tar.gz: 438194ab7ef0f1ad3f17a63e6306d426ae8e8a3544f33e78bb9e8292af7c7408
+  metadata.gz: f6c778b5c85e44e0bada5fd6b073bca7c5ad859dd7e7670970ded5828253f12f
+  data.tar.gz: 016efb08c0817d3075ec0d504ceaf00a79cd69021b0db2a3b00445592a04e6b9
 SHA512:
-  metadata.gz: 946cddafc751a2b2c9c385911080871a3f7b43231814cf2b351728cc0ae9eaf1297e30e1ed604d6d150ce4c5add9fc74820660e53a61e9b9528691ae805c15d4
-  data.tar.gz: f8218e47483f166fb9bbc3f036b86a8bde0aced4c1e34a8c3be1558d94eb54c98c7159b432d6e1c3533df5f92991cd7184cb6403806f8bb0ed8c661ffb42b42e
+  metadata.gz: 6a4781c4a6edb5d16078cd48be9379d862be9d13c6f62ba849b86fe872c33411541456bba91ed64ae96125b9526053976a77910ddcaae68e92227391378a7d83
+  data.tar.gz: 9bcd652ff1be61710625ab18fb20af9e765f49be8f02e940b6b3ebab2a43e679fb0299a9faa354501229c6f411fd76a3698db4ea29404ae15baf9b5693eb338e

data/CHANGES.md

@@ -1,3 +1,11 @@
+# 0.2.7
+
+* `Did you mean ?` suggestions on Linear::Sequence::IndexError.
+* Introduce `Linear::Helper` module for strategy extensions in third-party gems.
+* Convenient way to patch Subprocess itself using `patch` option.
+* Allow multiple `Path()` macro per step.
+* Small fix for defining instance methods as steps using circuit interface.
+
 # 0.2.6
 
 * Added `@fields` to `Linear::State` to save arbitrary data on the activity/strategy level.

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

@@ -37,7 +37,17 @@ class Trailblazer::Activity
           sequence
         end
 
-        class IndexError < IndexError; end
+        class IndexError < IndexError
+          attr_reader :step_id
+
+          def initialize(sequence, step_id)
+            @step_id  = step_id
+            valid_ids = sequence.collect{ |row| row[3][:id].inspect }
+
+            message = %{#{@step_id.inspect} is not a valid step ID. Did you mean any of these ?\n#{valid_ids.join("\n")}}
+            super(message)
+          end
+        end
       end
 
       # Sequence
@@ -111,7 +121,7 @@ class Trailblazer::Activity
         end
 
         def find(sequence, insert_id)
-          index = find_index(sequence, insert_id) or raise Sequence::IndexError.new(insert_id.inspect)
+          index = find_index(sequence, insert_id) or raise Sequence::IndexError.new(sequence, insert_id)
 
           return index, sequence.clone # Ruby doesn't have an easy way to avoid mutating arrays :(
         end
@@ -157,10 +167,10 @@ end
 
 require "trailblazer/activity/dsl/linear/normalizer"
 require "trailblazer/activity/dsl/linear/state"
+require "trailblazer/activity/dsl/linear/helper"
 require "trailblazer/activity/dsl/linear/strategy"
 require "trailblazer/activity/dsl/linear/compiler"
 require "trailblazer/activity/path"
 require "trailblazer/activity/railway"
 require "trailblazer/activity/fast_track"
-require "trailblazer/activity/dsl/linear/helper" # FIXME
 require "trailblazer/activity/dsl/linear/variable_mapping"

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

@@ -1,125 +1,144 @@
 module Trailblazer
   class Activity
-    module DSL::Linear # TODO: rename!
-      # @api private
-      OutputSemantic = Struct.new(:value)
-      Id             = Struct.new(:value)
-      Track          = Struct.new(:color, :adds)
-      Extension      = Struct.new(:callable) do
-        def call(*args, &block)
-          callable.(*args, &block)
-        end
-      end
-
-      # Shortcut functions for the DSL.
-      module_function
-
-      #   Output( Left, :failure )
-      #   Output( :failure ) #=> Output::Semantic
-      def Output(signal, semantic=nil)
-        return OutputSemantic.new(signal) if semantic.nil?
-
-        Activity.Output(signal, semantic)
-      end
-
-      def End(semantic)
-        Activity.End(semantic)
-      end
-
-      def end_id(_end)
-        "End.#{_end.to_h[:semantic]}" # TODO: use everywhere
-      end
-
-      def Track(color)
-        Track.new(color, []).freeze
-      end
-
-      def Id(id)
-        Id.new(id).freeze
-      end
-
-      def Path(track_color: "track_#{rand}", end_id:"path_end_#{rand}", connect_to:nil, **options, &block)
-        # DISCUSS: here, we use the global normalizer and don't allow injection.
-        state = Activity::Path::DSL::State.new(Activity::Path::DSL.OptionsForState(track_name: track_color, end_id: end_id, **options)) # TODO: test injecting {:normalizers}.
-
-        # seq = block.call(state) # state changes.
-        state.instance_exec(&block)
-
-        seq = state.to_h[:sequence]
-
-        _end_id =
-          if connect_to
-            end_id
-          else
-            nil
+    module DSL
+      module Linear
+        module Helper
+          # @api private
+          OutputSemantic = Struct.new(:value)
+          Id             = Struct.new(:value)
+          Track          = Struct.new(:color, :adds)
+          Extension      = Struct.new(:callable) do
+            def call(*args, &block)
+              callable.(*args, &block)
+            end
+          end
+
+          def self.included(base)
+            base.extend ClassMethods
           end
 
-        seq = strip_start_and_ends(seq, end_id: _end_id) # don't cut off end unless {:connect_to} is set.
+          # Shortcut functions for the DSL.
+          module ClassMethods
+            #   Output( Left, :failure )
+            #   Output( :failure ) #=> Output::Semantic
+            def Output(signal, semantic=nil)
+              return OutputSemantic.new(signal) if semantic.nil?
+
+              Activity.Output(signal, semantic)
+            end
+
+            def End(semantic)
+              Activity.End(semantic)
+            end
+
+            def end_id(_end)
+              "End.#{_end.to_h[:semantic]}" # TODO: use everywhere
+            end
+
+            def Track(color)
+              Track.new(color, []).freeze
+            end
+
+            def Id(id)
+              Id.new(id).freeze
+            end
+
+            def Path(track_color: "track_#{rand}", end_id:"path_end_#{rand}", connect_to:nil, **options, &block)
+              # DISCUSS: here, we use the global normalizer and don't allow injection.
+              state = Activity::Path::DSL::State.new(Activity::Path::DSL.OptionsForState(track_name: track_color, end_id: end_id, **options)) # TODO: test injecting {:normalizers}.
+
+              # seq = block.call(state) # state changes.
+              state.instance_exec(&block)
 
-        if connect_to
-          output, _ = seq[-1][2][0].(seq, seq[-1]) # FIXME: the Forward() proc contains the row's Output, and the only current way to retrieve it is calling the search strategy. It should be Forward#to_h
+              seq = state.to_h[:sequence]
 
-          searches = [Search.ById(output, connect_to.value)]
+              _end_id =
+                if connect_to
+                  end_id
+                else
+                  nil
+                end
 
-          row = seq[-1]
-          row = row[0..1] + [searches] + [row[3]] # FIXME: not mutating an array is so hard: we only want to replace the "searches" element, index 2
+              seq = strip_start_and_ends(seq, end_id: _end_id) # don't cut off end unless {:connect_to} is set.
 
-          seq = seq[0..-2] + [row]
-        end
+              if connect_to
+                output, _ = seq[-1][2][0].(seq, seq[-1]) # FIXME: the Forward() proc contains the row's Output, and the only current way to retrieve it is calling the search strategy. It should be Forward#to_h
 
-        # Add the path before End.success - not sure this is bullet-proof.
-        adds = seq.collect do |row|
-          {
-            row:    row,
-            insert: [Insert.method(:Prepend), "End.success"]
-          }
-        end
+                searches = [Search.ById(output, connect_to.value)]
 
-        # Connect the Output() => Track(path_track)
-        return Track.new(track_color, adds)
-      end
+                row = seq[-1]
+                row = row[0..1] + [searches] + [row[3]] # FIXME: not mutating an array is so hard: we only want to replace the "searches" element, index 2
 
-      # Computes the {:outputs} options for {activity}.
-      def Subprocess(activity, patch: {})
-        patch.each do |path, patch|
-          activity = Patch.(activity, path, patch) # TODO: test if multiple patches works!
-        end
+                seq = seq[0..-2] + [row]
+              end
 
-        {
-          task:    activity,
-          outputs: Hash[activity.to_h[:outputs].collect { |output| [output.semantic, output] }]
-        }
-      end
+              # Add the path before End.success - not sure this is bullet-proof.
+              adds = seq.collect do |row|
+                {
+                  row:    row,
+                  insert: [Insert.method(:Prepend), "End.success"]
+                }
+              end
+
+              # Connect the Output() => Track(path_track)
+              return Track.new(track_color, adds)
+            end
+
+            # Computes the {:outputs} options for {activity}.
+            def Subprocess(activity, patch: {})
+              activity = Patch.customize(activity, options: patch)
+
+              {
+                task:    activity,
+                outputs: Hash[activity.to_h[:outputs].collect { |output| [output.semantic, output] }]
+              }
+            end
 
-      module Patch
-        module_function
+            module Patch
+              module_function
 
-        def call(activity, path, customization)
-          task_id, *path = path
+              def customize(activity, options:)
+                options = options.is_a?(Proc) ?
+                  { [] => options } : # hash-wrapping with empty path, for patching given activity itself
+                  options
 
+                options.each do |path, patch|
+                  activity = call(activity, path, patch) # TODO: test if multiple patches works!
+                end
 
-          patch =
-            if task_id
-              segment_activity = Introspect::Graph(activity).find(task_id).task
-              patched_segment_activity = call(segment_activity, path, customization)
+                activity
+              end
 
-              # Replace the patched subprocess.
-              -> { step Subprocess(patched_segment_activity), replace: task_id, id: task_id }
-            else
-              customization # apply the *actual* patch from the Subprocess() call.
+              def call(activity, path, customization)
+                task_id, *path = path
+
+                patch =
+                  if task_id
+                    segment_activity = Introspect::Graph(activity).find(task_id).task
+                    patched_segment_activity = call(segment_activity, path, customization)
+
+                    # Replace the patched subprocess.
+                    -> { step Subprocess(patched_segment_activity), replace: task_id, id: task_id }
+                  else
+                    customization # apply the *actual* patch from the Subprocess() call.
+                  end
+
+                patched_activity = Class.new(activity)
+                patched_activity.class_exec(&patch)
+                patched_activity
+              end
             end
 
-          patched_activity = Class.new(activity)
-          patched_activity.class_exec(&patch)
-          patched_activity
-        end
-      end
-
-      def normalize(options, local_keys) # TODO: test me.
-        locals  = options.reject { |key, value| ! local_keys.include?(key) }
-        foreign = options.reject { |key, value| local_keys.include?(key) }
-        return foreign, locals
-      end
-    end
-  end
+            def normalize(options, local_keys) # TODO: test me.
+              locals  = options.reject { |key, value| ! local_keys.include?(key) }
+              foreign = options.reject { |key, value| local_keys.include?(key) }
+              return foreign, locals
+            end
+          end
+        end # Helper
+
+        include Helper # Introduce Helper constants in DSL::Linear scope
+      end # Linear
+    end # DSL
+  end # Activity
 end

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

@@ -53,7 +53,13 @@ module Trailblazer
           # 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, flow_options), *)
-            options = ctx[:options] # either a <#task> or {} from macro
+            options = case (step_args = ctx[:options]) # either a <#task> or {} from macro
+                      when Hash
+                        # extract task for interfaces like `step task: :instance_method_name`
+                        step_args[:task].is_a?(Symbol) ? step_args[:task] : step_args
+                      else
+                        step_args
+                      end
 
             unless options.is_a?(::Hash)
               # task = wrap_with_step_interface(task: options, step_interface_builder: ctx[:user_options][:step_interface_builder]) # TODO: make this optional with appropriate wiring.
@@ -157,6 +163,8 @@ module Trailblazer
                   _adds      = [add_end(cfg, magnetic_to: end_id, id: end_id)] unless end_exists
 
                   [output_to_id(ctx, output, end_id), _adds]
+                else
+                  raise cfg.inspect
                 end
 
               connections = connections.merge(new_connections)

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

@@ -1,5 +1,3 @@
-require "forwardable"
-
 module Trailblazer
   class Activity
     module DSL
@@ -58,23 +56,29 @@ module Trailblazer
 
           private def forward_block(args, block)
             options = args[1]
-            if options.is_a?(Hash) # FIXME: doesn't account {task: <>} and repeats logic from Normalizer.
-              output, proxy = (options.find { |k,v| v.is_a?(BlockProxy) } or return args)
+
+            return args unless options.is_a?(Hash)
+
+              # FIXME: doesn't account {task: <>} and repeats logic from Normalizer.
+
+            # DISCUSS: THIS SHOULD BE DONE IN DSL.Path() which is stateful! the block forwarding should be the only thing happening here!
+            evaluated_options =
+            options.find_all { |k,v| v.is_a?(BlockProxy) }.collect do |output, proxy|
               shared_options = {step_interface_builder: @state.instance_variable_get(:@normalizer_options)[:step_interface_builder]} # FIXME: how do we know what to pass on and what not?
-              return args[0], options.merge(output => Linear.Path(**shared_options, **proxy.options, &block))
+
+              [output, Linear.Path(**shared_options, **proxy.options, &(proxy.block || block))] # FIXME: the || sucks.
             end
 
-            args
-          end
+            evaluated_options = Hash[evaluated_options]
 
-          extend Forwardable
-          def_delegators Linear, :Output, :End, :Track, :Id, :Subprocess
+            return args[0], options.merge(evaluated_options)
+          end
 
-          def Path(options) # we can't access {block} here, syntactically.
-            BlockProxy.new(options)
+          def Path(options, &block) # syntactically, we can't access the {do ... end} block here.
+            BlockProxy.new(options, block)
           end
 
-          BlockProxy = Struct.new(:options)
+          BlockProxy = Struct.new(:options, :block)
 
           private def merge!(activity)
             old_seq = @state.instance_variable_get(:@sequence) # TODO: fixme

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

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

data/lib/trailblazer/activity/fast_track.rb

@@ -154,6 +154,7 @@ module Trailblazer
         end
       end
 
+      include Activity::DSL::Linear::Helper
       extend Activity::DSL::Linear::Strategy
 
       initialize!(Railway::DSL::State.new(DSL.OptionsForState()))

data/lib/trailblazer/activity/path.rb

@@ -177,6 +177,7 @@ module Trailblazer
 
       end # DSL
 
+      include DSL::Linear::Helper
       extend DSL::Linear::Strategy
 
       initialize!(Path::DSL::State.new(DSL.OptionsForState()))

data/lib/trailblazer/activity/railway.rb

@@ -157,6 +157,7 @@ module Trailblazer
         end
       end
 
+      include DSL::Linear::Helper
       extend DSL::Linear::Strategy
 
       initialize!(Railway::DSL::State.new(DSL.OptionsForState()))

metadata

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