nxt_pipeline 0.3.1 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: be4eec17fa6c2abc134a5e02ef10681e60397e1b358a54c593e38faabcaa28f0
-  data.tar.gz: a109440aa292f3f33be8cc43b4ceadfef9b7e7869d8e701dd2a0afebf37f62d2
+  metadata.gz: e8762564262fbcc4274226dd10acd423e960f31624ae20ca539a4951a626e211
+  data.tar.gz: 17f1adb27f76aaddf71e2dd00ae303e8837560e4fdfae911a98812f30408e541
 SHA512:
-  metadata.gz: 3fc83095718bc6e4e2a8d1827e3e59ab1e03abe3e5b14994a8aa2699f4a996bc72cb85439a52720df378310ec93fb8de4009f483ddec31fa2b06b6b8e7a6dd8d
-  data.tar.gz: 6244dcbcea68037108f6b91f0d15489ebc61cbe03b950d3f4306b66f24f5fd849401124a7816a9b3a940eebb11dad73f13ce36718e25047bed1951d7b20a8efc
+  metadata.gz: efb282aef978706713a0f76332a66298c99d5278794e6935742d08a5d54d271d9c01a633e0c8fcf7d5b67a4c0f945d3fe4de64b871558e7e4a80ac5e87088264
+  data.tar.gz: 48b4ba6cbb45a9a7f2848e70bc3bd4e6bde884badf820e74cda8d1fea69903f5119204bc073f5f8b6e6386ef6c805f5b0e009938dd881a024d8842947a3697e5

data/Gemfile.lock

@@ -1,17 +1,18 @@
 PATH
   remote: .
   specs:
-    nxt_pipeline (0.3.1)
+    nxt_pipeline (0.4.0)
       activesupport
 
 GEM
   remote: https://rubygems.org/
   specs:
-    activesupport (5.2.3)
+    activesupport (6.0.0)
       concurrent-ruby (~> 1.0, >= 1.0.2)
       i18n (>= 0.7, < 2)
       minitest (~> 5.1)
       tzinfo (~> 1.1)
+      zeitwerk (~> 2.1, >= 2.1.8)
     coderay (1.1.2)
     concurrent-ruby (1.1.5)
     diff-lcs (1.3)
@@ -72,6 +73,7 @@ GEM
     thread_safe (0.3.6)
     tzinfo (1.2.5)
       thread_safe (~> 0.1)
+    zeitwerk (2.1.9)
 
 PLATFORMS
   ruby

data/README.md

@@ -90,11 +90,11 @@ will be set to :inline.
 You can then execute the steps with: 
 
 ```ruby
-pipeline.execute('initial argument')
+pipeline.execute(arg: 'initial argument')
 
 # Or run the steps directly using block syntax
 
-pipeline.execute('initial argument') do |p|
+pipeline.execute(arg: 'initial argument') do |p|
   p.step :service, service_class: MyServiceClass, to_s: 'First step'
   p.step :service, service_class: MyOtherServiceClass, to_s: 'Second step'
   p.step :job, job_class: MyJobClass # to_s is optional
@@ -106,7 +106,7 @@ end
 You can also directly execute a pipeline with:
 
 ```ruby
-NxtPipeline::Pipeline.execute('initial argument') do |p|
+NxtPipeline::Pipeline.execute(arg: 'initial argument') do |p|
   p.step do |_, arg:|
     { arg: arg.upcase }
   end
@@ -137,7 +137,7 @@ You can also define guard clauses that take a proc to prevent the execution of a
 When the guard takes an argument the step argument is yielded.  
 
  ```ruby
- pipeline.execute('initial argument') do |p|
+ pipeline.execute(arg: 'initial argument') do |p|
    p.step :service, service_class: MyServiceClass, if: -> (arg:) { arg == 'initial argument' }
    p.step :service, service_class: MyOtherServiceClass, unless: -> { false }
  end

data/lib/nxt_pipeline/dsl.rb

@@ -1,27 +1,22 @@
 module NxtPipeline
   module Dsl
     module ClassMethods
-      def pipeline(name = :default, &block)
+      def pipeline(name = :default, parent = NxtPipeline::Pipeline, &block)
         name = name.to_sym
-
-        if block_given?
-          raise_already_registered_error(name) if pipeline_registry.key?(name)
-          pipeline_registry[name] = block
-        else
-          config = pipeline_registry.fetch(name) { raise KeyError, "No pipeline #{name} registered"}
-          NxtPipeline::Pipeline.new(&config)
-        end
+        raise ArgumentError, "No block given!" unless block_given?
+        raise_already_registered_error(name) if pipeline_registry.key?(name)
+        register_pipeline(name, block, parent)
       end
 
-      def pipeline!(name, &block)
+      def pipeline!(name, parent = NxtPipeline::Pipeline, &block)
         raise ArgumentError, "No block given!" unless block_given?
-        pipeline_registry[name] = block
+        register_pipeline(name, block, parent)
       end
 
       private
 
       def inherited(child)
-        child.instance_variable_set(:@pipeline_registry, pipeline_registry.clone)
+        child.instance_variable_set(:@pipeline_registry, pipeline_registry.deep_dup)
       end
 
       def raise_already_registered_error(name)
@@ -31,13 +26,22 @@ module NxtPipeline
       def pipeline_registry
         @pipeline_registry ||= ActiveSupport::HashWithIndifferentAccess.new
       end
+
+      def register_pipeline(name, block, parent)
+        pipeline_registry[name] = { config: block, parent: parent }
+      end
     end
 
     def self.included(base)
       base.extend(ClassMethods)
 
       def pipeline(name = :default)
-        self.class.pipeline(name)
+        registry = self.class.send(:pipeline_registry)
+        entry = registry.fetch(name) { raise KeyError, "No pipeline #{name} registered"}
+        config = entry.fetch(:config)
+        pipeline = entry.fetch(:parent).new
+        instance_exec(pipeline, &config)
+        pipeline
       end
     end
   end

data/lib/nxt_pipeline/pipeline.rb

@@ -4,14 +4,15 @@ module NxtPipeline
       new(&block).execute(**opts)
     end
 
-    def initialize(&block)
+    def initialize(step_resolvers = default_step_resolvers, &block)
       @steps = []
       @error_callbacks = []
       @logger = Logger.new
       @current_step = nil
       @current_arg = nil
       @default_constructor_name = nil
-      @registry = {}
+      @constructors = {}
+      @step_resolvers = step_resolvers
 
       configure(&block) if block_given?
     end
@@ -22,14 +23,18 @@ module NxtPipeline
 
     def constructor(name, **opts, &constructor)
       name = name.to_sym
-      raise StandardError, "Already registered step :#{name}" if registry[name]
+      raise StandardError, "Already registered step :#{name}" if constructors[name]
 
-      registry[name] = Constructor.new(name, opts, constructor)
+      constructors[name] = Constructor.new(name, opts, constructor)
 
       return unless opts.fetch(:default, false)
       set_default_constructor(name)
     end
 
+    def step_resolver(&block)
+      step_resolvers << block
+    end
+
     def set_default_constructor(name)
       raise_duplicate_default_constructor if default_constructor_name.present?
       self.default_constructor_name = name
@@ -39,43 +44,44 @@ module NxtPipeline
       raise ArgumentError, 'Default step already defined'
     end
 
-    def step(type = nil, **opts, &block)
-      type = type&.to_sym
-
+    def step(argument = nil, **opts, &block)
       constructor = if block_given?
         # make type the :to_s of inline steps
         # fall back to :inline if no type is given
-        type ||= :inline
-        opts.reverse_merge!(to_s: type)
-        Constructor.new(type, opts, block)
+        argument ||= :inline
+        opts.reverse_merge!(to_s: argument)
+        Constructor.new(:inline, opts, block)
       else
-        if type
-          raise_reserved_type_inline_error if type == :inline
-          registry.fetch(type) { raise KeyError, "No step :#{type} registered" }
+        constructor = step_resolvers.lazy.map do |resolver|
+          resolver.call(argument)
+        end.find(&:itself)
+
+        if constructor
+          constructor && constructors.fetch(constructor) { raise KeyError, "No step :#{argument} registered" }
+        elsif default_constructor
+          argument ||= default_constructor_name
+          default_constructor
         else
-          # When no type was given we try to fallback to the type of the default constructor
-          type = default_constructor_name
-          # If none was given - raise
-          default_constructor || (raise StandardError, 'No default step registered')
+          raise StandardError, "Could not resolve step from: #{argument}"
         end
       end
 
-      steps << Step.new(type, constructor, steps.count, **opts)
+      steps << Step.new(argument, constructor, steps.count, **opts)
     end
 
-    def execute(**opts, &block)
+    def execute(**changeset, &block)
       reset
 
       configure(&block) if block_given?
-      before_execute_callback.call(self, opts) if before_execute_callback.respond_to?(:call)
+      before_execute_callback.call(self, changeset) if before_execute_callback.respond_to?(:call)
 
-      result = steps.inject(opts) do |options, step|
-        execute_step(step, **options)
+      result = steps.inject(changeset) do |changeset, step|
+        execute_step(step, **changeset)
       rescue StandardError => error
         callback = find_error_callback(error)
         raise unless callback && callback.continue_after_error?
         handle_step_error(error)
-        options
+        changeset
       end
 
       after_execute_callback.call(self, result) if after_execute_callback.respond_to?(:call)
@@ -109,7 +115,7 @@ module NxtPipeline
 
     private
 
-    attr_reader :error_callbacks, :registry
+    attr_reader :error_callbacks, :constructors, :step_resolvers
     attr_accessor :current_step,
                   :current_arg,
                   :default_constructor_name,
@@ -119,15 +125,15 @@ module NxtPipeline
     def default_constructor
       return unless default_constructor_name
 
-      @default_constructor ||= registry[default_constructor_name.to_sym]
+      @default_constructor ||= constructors[default_constructor_name.to_sym]
     end
 
-    def execute_step(step, **opts)
+    def execute_step(step, **changeset)
       self.current_step = step
-      self.current_arg = opts
-      result = step.execute(**opts)
+      self.current_arg = changeset
+      result = step.execute(**changeset)
       log_step(step)
-      result || opts
+      result || changeset
     end
 
     def find_error_callback(error)
@@ -148,5 +154,9 @@ module NxtPipeline
     def raise_reserved_type_inline_error
       raise ArgumentError, 'Type :inline is reserved for inline steps!'
     end
+
+    def default_step_resolvers
+      [->(step_argument) { step_argument.is_a?(Symbol) && step_argument }]
+    end
   end
 end

data/lib/nxt_pipeline/step.rb

@@ -1,32 +1,41 @@
 module NxtPipeline
   class Step
-    def initialize(type, constructor, index, **opts)
+    def initialize(argument, constructor, index, **opts)
       define_attr_readers(opts)
 
-      @type = type
+      @argument = argument
       @index = index
       @opts = opts
       @constructor = constructor
-      @to_s = "#{opts.merge(type: type)}"
+      @to_s = "#{opts.merge(argument: argument)}"
+      @options_mapper = opts[:map_options]
 
       @status = nil
       @result = nil
       @error = nil
+      @mapped_options = nil
     end
 
-    attr_reader :type, :result, :status, :error, :opts, :index
+    attr_reader :argument, :result, :status, :error, :opts, :index, :mapped_options
     attr_accessor :to_s
 
     alias_method :name=, :to_s=
     alias_method :name, :to_s
 
-    def execute(**opts)
-      guard_args = [opts, self]
+    def execute(**changeset)
+      mapper = options_mapper || default_options_mapper
+      mapper_args = [changeset, self].take(mapper.arity)
+      self.mapped_options = mapper.call(*mapper_args)
+
+      guard_args = [changeset, self]
+
       if_guard_args = guard_args.take(if_guard.arity)
       unless_guard_guard_args = guard_args.take(unless_guard.arity)
 
       if !unless_guard.call(*unless_guard_guard_args) && if_guard.call(*if_guard_args)
-        self.result = constructor.call(self, **opts)
+        constructor_args = [self, changeset]
+        constructor_args = constructor_args.take(constructor.arity)
+        self.result = constructor.call(*constructor_args)
       end
 
       set_status
@@ -37,14 +46,14 @@ module NxtPipeline
       raise
     end
 
-    def type?(potential_type)
-      type.to_sym == potential_type.to_sym
-    end
+    # def type?(potential_type)
+    #   constructor.resolve_type(potential_type)
+    # end
 
     private
 
-    attr_writer :result, :status, :error
-    attr_reader :constructor
+    attr_writer :result, :status, :error, :mapped_options
+    attr_reader :constructor, :options_mapper
 
     def if_guard
       opts.fetch(:if) { guard(true) }
@@ -69,5 +78,10 @@ module NxtPipeline
     def set_status
       self.status = result.present? ? :success : :skipped
     end
+
+    def default_options_mapper
+      # returns an empty hash
+      ->(changeset) { {} }
+    end
   end
 end

data/lib/nxt_pipeline/version.rb

@@ -1,3 +1,4 @@
 module NxtPipeline
-  VERSION = "0.3.1".freeze
+  VERSION = "0.4.0".freeze
 end
+

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: nxt_pipeline
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.4.0
 platform: ruby
 authors:
 - Nils Sommer
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-08-13 00:00:00.000000000 Z
+date: 2019-08-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport