nxt_pipeline 0.4.2 → 2.0.0

data/lib/nxt_pipeline/pipeline.rb

@@ -1,10 +1,10 @@
 module NxtPipeline
   class Pipeline
-    def self.execute(**opts, &block)
-      new(&block).execute(**opts)
+    def self.call(acc, configuration: nil, resolvers: [], &block)
+      new(configuration: configuration, resolvers: resolvers, &block).call(acc)
     end
 
-    def initialize(step_resolvers = default_step_resolvers, &block)
+    def initialize(configuration: nil, resolvers: [], &block)
       @steps = []
       @error_callbacks = []
       @logger = Logger.new
@@ -12,90 +12,156 @@ module NxtPipeline
       @current_arg = nil
       @default_constructor_name = nil
       @constructors = {}
-      @step_resolvers = step_resolvers
+      @constructor_resolvers = resolvers
+      @result = nil
+
+      if configuration.present?
+        config = ::NxtPipeline.configuration(configuration)
+        configure(&config)
+      end
 
       configure(&block) if block_given?
     end
 
     alias_method :configure, :tap
 
-    attr_accessor :logger, :steps
+    attr_accessor :logger
+    attr_reader :result
 
-    def constructor(name, **opts, &constructor)
+    def constructor(name, default: false, &constructor)
       name = name.to_sym
       raise StandardError, "Already registered step :#{name}" if constructors[name]
 
-      constructors[name] = Constructor.new(name, **opts, &constructor)
+      constructors[name] = constructor
 
-      return unless opts.fetch(:default, false)
+      return unless default
       set_default_constructor(name)
     end
 
-    def step_resolver(&block)
-      step_resolvers << block
+    def constructor_resolver(&block)
+      constructor_resolvers << block
     end
 
-    def set_default_constructor(name)
+    def set_default_constructor(default_constructor)
       raise_duplicate_default_constructor if default_constructor_name.present?
-      self.default_constructor_name = name
+      self.default_constructor_name = default_constructor
     end
 
     def raise_duplicate_default_constructor
       raise ArgumentError, 'Default step already defined'
     end
 
-    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
-        argument ||= :inline
-        opts.reverse_merge!(to_s: argument)
-        Constructor.new(:inline, **opts, &block)
+    # Overwrite reader to also define steps
+    def steps(steps = [])
+      return @steps unless steps.any?
+
+      steps.each do |args|
+        arguments = Array(args)
+        if arguments.size == 1
+          step(arguments.first)
+        elsif arguments.size == 2
+          step(arguments.first, **arguments.second)
+        else
+          raise ArgumentError, "Either pass a single argument or an argument and options"
+        end
+      end
+    end
+
+    # Allow to force steps with setter
+    def steps=(steps = [])
+      # reset steps to be zero
+      @steps = []
+      steps(steps)
+    end
+
+    def step(argument, constructor: nil, **opts, &block)
+
+      if constructor.present? and block_given?
+        msg = "Either specify a block or a constructor but not both at the same time!"
+        raise ArgumentError, msg
+      end
+
+      to_s = if opts[:to_s].present?
+               opts[:to_s] = opts[:to_s].to_s
+             else
+               if argument.is_a?(Proc) || argument.is_a?(Method)
+                 steps.count.to_s
+               else
+                 argument.to_s
+               end
+             end
+
+
+      opts.reverse_merge!(to_s: to_s)
+
+      if constructor.present?
+        # p.step Service, constructor: ->(step, **changes) { ... }
+        if constructor.respond_to?(:call)
+          resolved_constructor = constructor
+        else
+          # p.step Service, constructor: :service
+          resolved_constructor = constructors.fetch(constructor) {
+            ::NxtPipeline.constructor(constructor) || (raise ArgumentError, "No constructor defined for #{constructor}")
+          }
+        end
+      elsif block_given?
+        # p.step :inline do ... end
+        resolved_constructor = block
       else
-        constructor = step_resolvers.lazy.map do |resolver|
-          resolver.call(argument)
+        # If no constructor was given try to resolve one
+        resolvers = constructor_resolvers.any? ? constructor_resolvers : []
+
+        constructor_from_resolvers = resolvers.map do |resolver|
+          resolver.call(argument, **opts)
         end.find(&:itself)
 
-        if constructor
-          constructor && constructors.fetch(constructor) { raise KeyError, "No step :#{argument} registered" }
-        elsif default_constructor
-          argument ||= default_constructor_name
-          default_constructor
+        # resolved constructor is a proc
+        if constructor_from_resolvers.is_a?(Proc)
+          resolved_constructor = constructor_from_resolvers
+        elsif constructor_from_resolvers.present?
+          resolved_constructor = constructors[constructor_from_resolvers]
         else
-          raise StandardError, "Could not resolve step from: #{argument}"
+          # try to resolve constructor by argument --> #TODO: Is this a good idea?
+          resolved_constructor = constructors[argument]
+        end
+
+
+        # if still no constructor resolved
+        unless resolved_constructor.present?
+          if argument.is_a?(NxtPipeline::Pipeline)
+            pipeline_constructor = ->(changes) { argument.call(changes) }
+            resolved_constructor = pipeline_constructor
+          # last chance: default constructor
+          elsif default_constructor.present?
+            resolved_constructor = default_constructor
+          # now we really give up :-(
+          else
+            raise ArgumentError, "Could neither find nor resolve any constructor for #{argument}, #{opts}"
+          end
         end
       end
 
-      steps << Step.new(argument, constructor, steps.count, **opts)
+      register_step(argument, resolved_constructor, callbacks, **opts)
     end
 
-    def execute(**changeset, &block)
+    def call(acc, &block)
       reset
 
       configure(&block) if block_given?
-      before_execute_callback.call(self, changeset) if before_execute_callback.respond_to?(:call)
-
-      result = steps.inject(changeset) do |changeset, step|
-        execute_step(step, **changeset)
-      rescue StandardError => error
-        logger_for_error = logger
-
-        error.define_singleton_method :details do
-          OpenStruct.new(
-            changeset: changeset,
-            logger: logger_for_error,
-            step: step
-          )
+      callbacks.run(:before, :execution, acc)
+
+      self.result = callbacks.around :execution, acc do
+        steps.inject(acc) do |changes, step|
+          self.result = call_step(step, changes)
+        rescue StandardError => error
+          decorate_error_with_details(error, changes, step, logger)
+          handle_error_of_step(step, error)
+          result
         end
-
-        callback = find_error_callback(error)
-        raise unless callback && callback.continue_after_error?
-        handle_step_error(error)
-        changeset
       end
 
-      after_execute_callback.call(self, result) if after_execute_callback.respond_to?(:call)
-      result
+      # callbacks.run(:after, :execution, result) TODO: Better pass result to callback?
+      self.result = callbacks.run(:after, :execution, acc) || result
     rescue StandardError => error
       handle_step_error(error)
     end
@@ -106,7 +172,7 @@ module NxtPipeline
 
       raise unless callback
 
-      callback.call(current_step, current_arg, error)
+      callback.call(error, current_arg, current_step)
     end
 
     def on_errors(*errors, halt_on_error: true, &callback)
@@ -115,22 +181,41 @@ module NxtPipeline
 
     alias :on_error :on_errors
 
-    def before_execute(&callback)
-      self.before_execute_callback = callback
+    def before_step(&block)
+      callbacks.register([:before, :step], block)
+    end
+
+    def after_step(&block)
+      callbacks.register([:after, :step], block)
+    end
+
+    def around_step(&block)
+      callbacks.register([:around, :step], block)
     end
 
-    def after_execute(&callback)
-      self.after_execute_callback = callback
+    def before_execution(&block)
+      callbacks.register([:before, :execution], block)
+    end
+
+    def after_execution(&block)
+      callbacks.register([:after, :execution], block)
+    end
+
+    def around_execution(&block)
+      callbacks.register([:around, :execution], block)
     end
 
     private
 
-    attr_reader :error_callbacks, :constructors, :step_resolvers
-    attr_accessor :current_step,
-                  :current_arg,
-                  :default_constructor_name,
-                  :before_execute_callback,
-                  :after_execute_callback
+    attr_writer :result
+
+    def callbacks
+      @callbacks ||= NxtPipeline::Callbacks.new(pipeline: self)
+    end
+
+    attr_reader :error_callbacks, :constructors, :constructor_resolvers
+    attr_writer :default_constructor_name
+    attr_accessor :current_step, :current_arg
 
     def default_constructor
       return unless default_constructor_name
@@ -138,12 +223,12 @@ module NxtPipeline
       @default_constructor ||= constructors[default_constructor_name.to_sym]
     end
 
-    def execute_step(step, **changeset)
+    def call_step(step, acc)
       self.current_step = step
-      self.current_arg = changeset
-      result = step.execute(**changeset)
+      self.current_arg = acc
+      result = step.call(acc)
       log_step(step)
-      result || changeset
+      result || acc
     end
 
     def find_error_callback(error)
@@ -161,12 +246,34 @@ module NxtPipeline
       self.current_step = nil
     end
 
-    def raise_reserved_type_inline_error
-      raise ArgumentError, 'Type :inline is reserved for inline steps!'
+
+    def decorate_error_with_details(error, change_set, step, logger)
+      error.define_singleton_method :details do
+        OpenStruct.new(
+          change_set: change_set,
+          logger: logger,
+          step: step
+        )
+      end
+      error
+    end
+
+    def register_step(argument, constructor, callbacks, **opts)
+      steps << Step.new(argument, constructor, steps.count, self, callbacks, **opts)
+    end
+
+    def handle_error_of_step(step, error)
+      error_callback = find_error_callback(error)
+      raise error unless error_callback.present? && error_callback.continue_after_error?
+
+      log_step(step)
+      raise error unless error_callback.present?
+
+      error_callback.call(error, current_arg, step)
     end
 
-    def default_step_resolvers
-      [->(step_argument) { step_argument.is_a?(Symbol) && step_argument }]
+    def default_constructor_name
+      @default_constructor_name || ::NxtPipeline.default_constructor_name
     end
   end
 end

data/lib/nxt_pipeline/step.rb

@@ -1,67 +1,96 @@
 module NxtPipeline
   class Step
-    def initialize(argument, constructor, index, **opts)
-      define_attr_readers(opts)
+    RESERVED_OPTION_KEYS  = %i[to_s unless if]
 
+    def initialize(argument, constructor, index, pipeline, callbacks, **opts)
+      @opts = opts.symbolize_keys
+
+      @pipeline = pipeline
+      @callbacks = callbacks
       @argument = argument
       @index = index
-      @opts = opts
       @constructor = constructor
-      @to_s = "#{opts.merge(argument: argument)}"
+      @to_s = opts.fetch(:to_s) { argument }
       @options_mapper = opts[:map_options]
 
       @status = nil
       @result = nil
       @error = nil
       @mapped_options = nil
+      @meta_data = nil
+
+      define_option_readers
     end
 
-    attr_reader :argument, :result, :status, :error, :opts, :index, :mapped_options
-    attr_accessor :to_s
+    attr_reader :argument,
+      :result,
+      :execution_started_at,
+      :execution_finished_at,
+      :execution_duration,
+      :error,
+      :opts,
+      :index,
+      :mapped_options
+
+    attr_writer :to_s
+    attr_accessor :meta_data, :status
+
+    def call(acc)
+      track_execution_time do
+        set_mapped_options(acc)
+        guard_args = [acc, self]
+
+        callbacks.run(:before, :step, acc)
+
+        if evaluate_unless_guard(guard_args) && evaluate_if_guard(guard_args)
+          callbacks.around(:step, acc) do
+            set_result(acc)
+          end
+        end
 
-    alias_method :name=, :to_s=
-    alias_method :name, :to_s
+        callbacks.run(:after, :step, acc)
+
+        set_status
+        result
+      end
+    rescue StandardError => e
+      self.status = :failed
+      self.error = e
+      raise
+    end
 
-    def execute(**changeset)
+    def set_mapped_options(acc)
       mapper = options_mapper || default_options_mapper
-      mapper_args = [changeset, self].take(mapper.arity)
+      mapper_args = [acc, self].take(mapper.arity)
       self.mapped_options = mapper.call(*mapper_args)
+    end
 
-      guard_args = [changeset, self]
+    def to_s
+      @to_s.to_s
+    end
 
-      if_guard_args = guard_args.take(if_guard.arity)
-      unless_guard_guard_args = guard_args.take(unless_guard.arity)
+    private
 
-      if !instrumentalize_callable(unless_guard, unless_guard_guard_args) && instrumentalize_callable(if_guard, if_guard_args)
-        constructor_args = [self, changeset]
-        constructor_args = constructor_args.take(constructor.arity)
+    attr_writer :result, :error, :mapped_options, :execution_started_at, :execution_finished_at, :execution_duration
+    attr_reader :constructor, :options_mapper, :pipeline, :callbacks
 
-        self.result = instrumentalize_callable(constructor, constructor_args)
-      end
+    def evaluate_if_guard(args)
+      execute_callable(if_guard, args)
+    end
 
-      set_status
-      result
-    rescue StandardError => e
-      self.status = :failed
-      self.error = e
-      raise
+    def evaluate_unless_guard(args)
+      !execute_callable(unless_guard, args)
     end
 
-    # def type?(potential_type)
-    #   constructor.resolve_type(potential_type)
-    # end
+    def set_result(acc)
+      args = [acc, self]
+      self.result = execute_callable(constructor, args)
+    end
 
-    private
+    def execute_callable(callable, args)
+      args = args.take(callable.arity) unless callable.arity.negative?
 
-    attr_writer :result, :status, :error, :mapped_options
-    attr_reader :constructor, :options_mapper
-    
-    def instrumentalize_callable(callable, args)
-      if args.last.is_a?(Hash)
-        callable.call(*args.take(args.length - 1), **args.last)
-      else
-        callable.call(*args)
-      end
+      callable.call(*args)
     end
 
     def if_guard
@@ -76,8 +105,10 @@ module NxtPipeline
       -> { result }
     end
 
-    def define_attr_readers(opts)
-      opts.each do |key, value|
+    def define_option_readers
+      raise ArgumentError, "#{invalid_option_keys} are not allowed as options" if invalid_option_keys.any?
+
+      options_without_reserved_options.each do |key, value|
         define_singleton_method key.to_s do
           value
         end
@@ -85,12 +116,46 @@ module NxtPipeline
     end
 
     def set_status
+      return if status.present? # We do not set it if the constructor did already
+
       self.status = result.present? ? :success : :skipped
     end
 
+    def track_execution_time(&block)
+      set_execution_started_at
+      block.call
+    ensure
+      set_execution_finished_at
+      set_execution_duration
+    end
+
+    def set_execution_started_at
+      self.execution_started_at = Time.current
+    end
+
+    def set_execution_finished_at
+      self.execution_finished_at = Time.current
+    end
+
+    def set_execution_duration
+      self.execution_duration = execution_finished_at - execution_started_at
+    end
+
     def default_options_mapper
       # returns an empty hash
-      ->(changeset) { {} }
+      ->(_) { {} }
+    end
+
+    def options_without_reserved_options
+      opts.except(*reserved_option_keys)
+    end
+
+    def reserved_option_keys
+      @reserved_option_keys ||= methods + RESERVED_OPTION_KEYS
+    end
+
+    def invalid_option_keys
+      opts.except(*RESERVED_OPTION_KEYS).keys & methods
     end
   end
 end

data/lib/nxt_pipeline/version.rb

@@ -1,4 +1,4 @@
 module NxtPipeline
-  VERSION = "0.4.2".freeze
+  VERSION = "2.0.0".freeze
 end
 

data/lib/nxt_pipeline.rb

@@ -1,10 +1,49 @@
 require 'active_support/all'
+require 'nxt_registry'
 require 'nxt_pipeline/version'
 require 'nxt_pipeline/logger'
-require 'nxt_pipeline/constructor'
 require 'nxt_pipeline/pipeline'
 require 'nxt_pipeline/step'
+require 'nxt_pipeline/callbacks'
 require 'nxt_pipeline/error_callback'
 
 module NxtPipeline
+  class << self
+    delegate :new, :call, to: Pipeline
+  end
+
+  def configuration(name, &block)
+    @configurations ||= {}
+
+    if block_given?
+      raise ArgumentError, "Configuration already defined for #{name}" if @configurations[name].present?
+      @configurations[name] = block
+    else
+      @configurations.fetch(name)
+    end
+  end
+
+  def constructor(name, default: false, &block)
+    @constructors ||= {}
+
+    if block_given?
+      raise ArgumentError, "Constructor already defined for #{name}" if @constructors[name].present?
+
+      default_constructor_name(name) if default
+      @constructors[name] = block
+    else
+      @constructors.fetch(name)
+    end
+  end
+
+  def default_constructor_name(name = nil)
+    if name.present?
+      raise ArgumentError, "Default constructor #{@default_constructor_name} defined already" if @default_constructor_name.present?
+      @default_constructor_name = name
+    else
+      @default_constructor_name
+    end
+  end
+
+  module_function :configuration, :constructor, :default_constructor_name
 end

data/nxt_pipeline.gemspec

@@ -35,6 +35,7 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
 
   spec.add_dependency "activesupport"
+  spec.add_dependency "nxt_registry"
   spec.add_development_dependency "bundler", "~> 2.1"
   spec.add_development_dependency "guard-rspec"
   spec.add_development_dependency "rake", "~> 13.0"

metadata

@@ -1,16 +1,16 @@
 --- !ruby/object:Gem::Specification
 name: nxt_pipeline
 version: !ruby/object:Gem::Version
-  version: 0.4.2
+  version: 2.0.0
 platform: ruby
 authors:
 - Nils Sommer
 - Andreas Robecke
 - Raphael Kallensee
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2020-10-13 00:00:00.000000000 Z
+date: 2022-05-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -26,6 +26,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: nxt_registry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -96,7 +110,7 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: 
+description:
 email:
 - mail@nilssommer.de
 executables: []
@@ -121,7 +135,7 @@ files:
 - bin/rspec
 - bin/setup
 - lib/nxt_pipeline.rb
-- lib/nxt_pipeline/constructor.rb
+- lib/nxt_pipeline/callbacks.rb
 - lib/nxt_pipeline/error_callback.rb
 - lib/nxt_pipeline/logger.rb
 - lib/nxt_pipeline/pipeline.rb
@@ -135,7 +149,7 @@ metadata:
   allowed_push_host: https://rubygems.org
   homepage_uri: https://github.com/nxt-insurance/nxt_pipeline
   source_code_uri: https://github.com/nxt-insurance/nxt_pipeline.git
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -151,7 +165,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubygems_version: 3.1.2
-signing_key: 
+signing_key:
 specification_version: 4
 summary: DSL to build Pipeline with mountable Segments to process things.
 test_files: []

data/lib/nxt_pipeline/constructor.rb

@@ -1,20 +0,0 @@
-module NxtPipeline
-  class Constructor
-    def initialize(name, **opts, &block)
-      @name = name
-      @block = block
-      @opts = opts
-    end
-
-    attr_reader :opts, :block
-    
-    delegate :arity, to: :block
-    
-    def call(*args, **opts, &block)
-      # ActiveSupport's #delegate does not properly handle keyword arg passing
-      # in the latest released version. Thefore we bypass delegation by reimplementing
-      # the method ourselves. This is already fixed in Rails master though.
-      self.block.call(*args, **opts, &block)
-    end
-  end
-end