nxt_pipeline 0.3.1 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: be4eec17fa6c2abc134a5e02ef10681e60397e1b358a54c593e38faabcaa28f0
-  data.tar.gz: a109440aa292f3f33be8cc43b4ceadfef9b7e7869d8e701dd2a0afebf37f62d2
+  metadata.gz: 77672035013c0cfe29bb5c5057178a9822e25c5b02e83b87a8cbb8dadac1d687
+  data.tar.gz: bb097fa702a19a9756d86a2ff63792bed998d9f8c5425263864695606bfca70d
 SHA512:
-  metadata.gz: 3fc83095718bc6e4e2a8d1827e3e59ab1e03abe3e5b14994a8aa2699f4a996bc72cb85439a52720df378310ec93fb8de4009f483ddec31fa2b06b6b8e7a6dd8d
-  data.tar.gz: 6244dcbcea68037108f6b91f0d15489ebc61cbe03b950d3f4306b66f24f5fd849401124a7816a9b3a940eebb11dad73f13ce36718e25047bed1951d7b20a8efc
+  metadata.gz: 2d355345b5aadcb3d02895cd85196cc60b34caef8c919d11480a5a2cd429c5e32baa37c83f8e169ca316311735343297ba0a3b763044e12ac02c8349cc849929
+  data.tar.gz: eeaa40df4479d0b4b39e5cfe5fd89756d6681dc3d9e9f96e65f6f1e4f9793c588298c33c0fa446c0f7ddf73a3a9e4a43c5da5f371cf25928f18c80bed52e3e58

data/.circleci/config.yml

@@ -7,7 +7,9 @@ jobs:
   build:
     docker:
       # specify the version you desire here
-      - image: circleci/ruby:2.6.1-node
+      - image: circleci/ruby:2.7.0-node
+    environment:
+      BUNDLER_VERSION: 2.1.4
 
     working_directory: ~/repo
 
@@ -19,6 +21,8 @@ jobs:
           keys:
             - v1-dependencies-{{ checksum "Gemfile.lock" }}
 
+      - run: gem install bundler --version $BUNDLER_VERSION
+
       - run:
           name: install dependencies
           command: |

data/.pryrc

@@ -0,0 +1,6 @@
+if defined?(PryByebug)
+  Pry.commands.alias_command 'c', 'continue'
+  Pry.commands.alias_command 's', 'step'
+  Pry.commands.alias_command 'n', 'next'
+  Pry.commands.alias_command 'f', 'finish'
+end

data/.ruby-version

@@ -1 +1 @@
-2.6.3
+2.7.0

data/CHANGELOG.md

@@ -1,4 +1,22 @@
-## Unreleased
+## nxt_pipeline 1.0.0 (24.11.2020)
+
+Replace after and before execute hooks with proper callbacks.
+Introduce before, after and around step callbacks
+
+## nxt_pipeline 0.4.3 (October 20, 2020)
+
+Add new attribute readers on step object.
+
+After executing a step execution_finished_at execution_started_at and execution_duration
+will be set and can be accessed via attribute readers.
+
+## nxt_pipeline 0.4.2 (October 12, 2020)
+
+* Fix bug when registering an error without passing arguments in which case the callback didn't get executed. More info: https://github.com/nxt-insurance/nxt_pipeline/issues/39
+
+## nxt_pipeline 0.4.1 (March 13, 2020)
+
+* Fix deprecation warnings for Ruby 2.7
 
 ## nxt_pipeline 0.2.0 (March 10, 2019)
 
@@ -14,7 +32,7 @@
   Renamed `NxtPipeline::Pipeline#burst?` to `NxtPipeline::Pipeline#failed?`.
   Renamed `NxtPipeline::Pipeline#burst_segment` to `NxtPipeline::Pipeline#failed_step`.
   Renamed `NxtPipeline::Pipeline::rescue_segment_burst` to `NxtPipeline::Pipeline::rescue_errors`.
-  
+
   *Nils Sommer*
 
 * Setup [guard](https://github.com/guard/guard) to run specs upon file changes during development.
@@ -29,4 +47,4 @@
 
 * Initial Release.
 
-  *Nils Sommer*
+  *Nils Sommer*

data/Gemfile.lock

@@ -1,23 +1,26 @@
 PATH
   remote: .
   specs:
-    nxt_pipeline (0.3.1)
+    nxt_pipeline (1.0.0)
       activesupport
+      nxt_registry
 
 GEM
   remote: https://rubygems.org/
   specs:
-    activesupport (5.2.3)
+    activesupport (6.1.1)
       concurrent-ruby (~> 1.0, >= 1.0.2)
-      i18n (>= 0.7, < 2)
-      minitest (~> 5.1)
-      tzinfo (~> 1.1)
-    coderay (1.1.2)
-    concurrent-ruby (1.1.5)
-    diff-lcs (1.3)
-    ffi (1.11.1)
+      i18n (>= 1.6, < 2)
+      minitest (>= 5.1)
+      tzinfo (~> 2.0)
+      zeitwerk (~> 2.3)
+    byebug (11.1.3)
+    coderay (1.1.3)
+    concurrent-ruby (1.1.8)
+    diff-lcs (1.4.4)
+    ffi (1.14.2)
     formatador (0.2.5)
-    guard (2.15.0)
+    guard (2.16.2)
       formatador (>= 0.2.4)
       listen (>= 2.7, < 4.0)
       lumberjack (>= 1.0.12, < 2.0)
@@ -31,59 +34,62 @@ GEM
       guard (~> 2.1)
       guard-compat (~> 1.1)
       rspec (>= 2.99.0, < 4.0)
-    i18n (1.6.0)
+    i18n (1.8.7)
       concurrent-ruby (~> 1.0)
-    listen (3.1.5)
-      rb-fsevent (~> 0.9, >= 0.9.4)
-      rb-inotify (~> 0.9, >= 0.9.7)
-      ruby_dep (~> 1.2)
-    lumberjack (1.0.13)
-    method_source (0.9.2)
-    minitest (5.11.3)
+    listen (3.4.1)
+      rb-fsevent (~> 0.10, >= 0.10.3)
+      rb-inotify (~> 0.9, >= 0.9.10)
+    lumberjack (1.2.8)
+    method_source (1.0.0)
+    minitest (5.14.3)
     nenv (0.3.0)
-    notiffany (0.1.1)
+    notiffany (0.1.3)
       nenv (~> 0.1)
       shellany (~> 0.0)
-    pry (0.12.2)
-      coderay (~> 1.1.0)
-      method_source (~> 0.9.0)
-    rake (12.3.3)
-    rb-fsevent (0.10.3)
-    rb-inotify (0.10.0)
+    nxt_registry (0.3.6)
+      activesupport
+    pry (0.13.1)
+      coderay (~> 1.1)
+      method_source (~> 1.0)
+    pry-byebug (3.9.0)
+      byebug (~> 11.0)
+      pry (~> 0.13.0)
+    rake (13.0.3)
+    rb-fsevent (0.10.4)
+    rb-inotify (0.10.1)
       ffi (~> 1.0)
-    rspec (3.8.0)
-      rspec-core (~> 3.8.0)
-      rspec-expectations (~> 3.8.0)
-      rspec-mocks (~> 3.8.0)
-    rspec-core (3.8.1)
-      rspec-support (~> 3.8.0)
-    rspec-expectations (3.8.4)
+    rspec (3.10.0)
+      rspec-core (~> 3.10.0)
+      rspec-expectations (~> 3.10.0)
+      rspec-mocks (~> 3.10.0)
+    rspec-core (3.10.1)
+      rspec-support (~> 3.10.0)
+    rspec-expectations (3.10.1)
       diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.8.0)
-    rspec-mocks (3.8.1)
+      rspec-support (~> 3.10.0)
+    rspec-mocks (3.10.1)
       diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.8.0)
-    rspec-support (3.8.2)
+      rspec-support (~> 3.10.0)
+    rspec-support (3.10.1)
     rspec_junit_formatter (0.4.1)
       rspec-core (>= 2, < 4, != 2.12.0)
-    ruby_dep (1.5.0)
     shellany (0.0.1)
-    thor (0.20.3)
-    thread_safe (0.3.6)
-    tzinfo (1.2.5)
-      thread_safe (~> 0.1)
+    thor (1.1.0)
+    tzinfo (2.0.4)
+      concurrent-ruby (~> 1.0)
+    zeitwerk (2.4.2)
 
 PLATFORMS
   ruby
 
 DEPENDENCIES
-  bundler (~> 1.17)
+  bundler (~> 2.1)
   guard-rspec
   nxt_pipeline!
-  pry
-  rake (~> 12.3)
+  pry-byebug
+  rake (~> 13.0)
   rspec (~> 3.0)
   rspec_junit_formatter
 
 BUNDLED WITH
-   1.17.2
+   2.1.4

data/README.md

@@ -24,35 +24,35 @@ Or install it yourself as:
 
 ### Constructors
 
-First you probably want to configure a pipeline so that it can execute your steps. 
-Therefore you want to define constructors for your steps. Constructors take a name 
+First you probably want to configure a pipeline so that it can execute your steps.
+Therefore you want to define constructors for your steps. Constructors take a name
 as the first argument and step options as the second. All step options are being exposed
-by the step yielded to the constructor. 
+by the step yielded to the constructor.
 
 ```ruby
 pipeline = NxtPipeline::Pipeline.new do |p|
   # Add a named constructor that will be used to execute your steps later
   # All options that you pass in your step will be available through accessors in your constructor
-  # You can call :to_s on a step to set it by default. You can later overwrite at execution for each step if needed. 
+  # You can call :to_s on a step to set it by default. You can later overwrite at execution for each step if needed.
   p.constructor(:service, default: true) do |step, arg:|
     step.to_s = step.service_class.to_s
     result = step.service_class.new(options: arg).call
     result && { arg: result }
   end
-  
+
   p.constructor(:job) do |step, arg:|
     step.job_class.perform_later(*arg) && { arg: arg }
   end
 end
 
-# Once a pipeline was created you can still configure it 
+# Once a pipeline was created you can still configure it
 pipeline.constructor(:call) do |step, arg:|
   result = step.caller.new(arg).call
   result && { arg: result }
 end
 
-# same with block syntax 
-# You can use this to split up execution from configuration  
+# same with block syntax
+# You can use this to split up execution from configuration
 pipeline.configure do |p|
  p.constructor(:call) do |step, arg:|
    result = step.caller.new(arg).call
@@ -61,13 +61,13 @@ pipeline.configure do |p|
 end
 ```
 
-### Defining steps 
+### Defining steps
 
 Once your pipeline knows how to execute your steps you can add those.
 
 ```ruby
 pipeline.step :service, service_class: MyServiceClass, to_s: 'First step'
-pipeline.step service_class: MyOtherServiceClass, to_s: 'Second step' 
+pipeline.step service_class: MyOtherServiceClass, to_s: 'Second step'
 # ^ Since service is the default step you don't have to specify it the step type each time
 pipeline.step :job, job_class: MyJobClass # to_s is optional
 pipeline.step :job, job_class: MyOtherJobClass
@@ -82,19 +82,19 @@ end
 ```
 
 You can also define inline steps, meaning the block will be executed. When you do not provide a :to_s option, type
-will be used as :to_s option per default. When no type was given for an inline block the type of the inline block 
-will be set to :inline. 
+will be used as :to_s option per default. When no type was given for an inline block the type of the inline block
+will be set to :inline.
 
 ### Execution
 
-You can then execute the steps with: 
+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,18 +106,18 @@ 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
 end
-``` 
+```
 
-You can query the steps of your pipeline simply by calling `pipeline.steps`. A NxtPipeline::Step will provide you with 
-an interface to it's type, options, status (:success, :skipped, :failed), result, error and the index in the pipeline.
+You can query the steps of your pipeline simply by calling `pipeline.steps`. A NxtPipeline::Step will provide you with
+an interface to it's type, options, status (:success, :skipped, :failed), execution_finished_at execution_started_at, execution_duration, result, error and the index in the pipeline.
 
 ```
-pipeline.steps.first 
+pipeline.steps.first
 # will give you something like this:
 
 #<NxtPipeline::Step:0x00007f83eb399448
@@ -128,20 +128,23 @@ pipeline.steps.first
  @opts={:to_s=>:transformer, :method=>:upcase},
  @result=nil,
  @status=nil,
- @type=:transformer> 
-``` 
+ @type=:transformer
+ @execution_duration=1.0e-05,
+ @execution_finished_at=2020-10-22 15:52:55.806417 +0100,
+ @execution_started_at=2020-10-22 15:52:55.806407 +0100,>
+```
 
 ### Guard clauses
 
 You can also define guard clauses that take a proc to prevent the execution of a step.
-When the guard takes an argument the step argument is yielded.  
+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
- 
+
  ```
 
 ### Error callbacks
@@ -153,98 +156,89 @@ NxtPipeline::Pipeline.new do |p|
   p.step do |_, arg:|
     { arg: arg.upcase }
   end
-  
+
   p.on_error MyCustomError do |step, opts, error|
     # First matching error callback will be executed!
   end
-  
+
   p.on_errors ArgumentError, KeyError do |step, opts, error|
     # First matching error callback will be executed!
   end
-  
+
   p.on_errors YetAnotherError, halt_on_error: false do |step, opts, error|
     # After executing the callback the pipeline will not halt but continue to
     # execute the next steps.
   end
-  
+
   p.on_errors do |step, opts, error|
     # This will match all errors inheriting from StandardError
   end
 end
-``` 
+```
 
-### Before and After callbacks
+### Before, around and after callbacks
 
-You can also define callbacks that run before and after the `#execute` action. Both callback blocks get the pipeline instance (to access stuff like the `log`) and the argument of the pipeline yielded.
+You can also define callbacks :before, :around and :after each step and or the `#execute` method. You can also register
+multiple callbacks, but probably you want to keep them to a minimum to not end up in hell.
+
+#### Step callbacks
 
 ```ruby
 NxtPipeline::Pipeline.new do |p|
-  p.before_execute do |pipeline, arg:|
-    # Will be called from within #execute before entering the first step
-    # After any configure block though!  
+  p.before_step do |_, change_set|
+    change_set[:acc] << 'before step 1'
+    change_set
   end
-  
-  p.after_execute do |pipeline, arg:|
-    # Will be called from within #execute after executing last step
+
+  p.around_step do |_, change_set, execution|
+    change_set[:acc] << 'around step 1'
+    execution.call # you have to specify where in your callback you want to call the inner block
+    change_set[:acc] << 'around step 1'
+    change_set
+  end
+
+  p.after_step do |_, change_set|
+    change_set[:acc] << 'after step 1'
+    change_set
   end
 end
 ```
 
-Note that the `after_execute` callback will not be called, when an error is raised in one of the steps. See the previous section (_Error callbacks_) for how to define callbacks that run in case of errors. 
-
-### DSL
-
-The gem also comes with an easy DSL to make pipeline handling in your code more convenient. 
-Simply include NxtPipeline::Dsl in your class:
+#### Execution callbacks
 
 ```ruby
-class MyAwesomeClass
-  include NxtPipeline::Dsl
-  
-  # register a pipeline with a name and a block
-  pipeline :validation do |p|
-    pipeline.constructor(:validate) do |step, arg:|
-      result = step.validator.call(arg: arg)
-      result && { arg: result }
-    end
-    
-    pipeline.step :validate, validator: NameValidator
-    pipeline.step :validate, validator: AdressValidator
-    pipeline.step :validate, validator: BankAccountValidator
-    pipeline.step :validate, validator: PhoneNumberValidator
-    
-    p.on_error ValidationError do |step, opts, error|
-      # ...
-    end
-  end
-  
-  pipeline :execution do |p|
-    p.step do |_, arg:|
-      { arg: arg.upcase }
-    end
-      
-    p.on_error MyCustomError do |step, opts, error|
-      # nesting pipelines also works
-      pipeline(:error).execute(error)
-    end
+NxtPipeline::Pipeline.new do |p|
+  p.before_execution do |_, change_set|
+    change_set[:acc] << 'before execution 1'
+    change_set
   end
-  
-  pipeline :error do |p|
-    p.step do |_, error|
-      error # do something here
-    end
+
+  p.around_execution do |_, change_set, execution|
+    change_set[:acc] << 'around execution 1'
+    execution.call # you have to specify where in your callback you want to call the inner block
+    change_set[:acc] << 'around execution 1'
+    change_set
   end
-  
-  def call(arg)
-    # execute a pipeline simply by fetching it and calling execute on it as you would normally
-    pipeline(:execution).execute(arg: arg)
+
+  p.after_execution do |_, change_set|
+    change_set[:acc] << 'after execution 1'
+    change_set
   end
 end
 ```
 
+Note that the `after_execute` callback will not be called in case a step raises an error. 
+See the previous section (_Error callbacks_) for how to define callbacks that run in case of errors.
+
+### Step resolvers
+
+NxtPipeline is using so called step_resolvers to find the constructor for a given step by the arguments passed in.
+You can also use this if you are not fine with resolving the constructor from the step argument. Check out the
+`nxt_pipeline/spec/step_resolver_spec.rb` for examples how you can implement your own step_resolvers.
+
+
 ## Topics
-- Step orchestration (chainable steps)
-- Constructors should take arg as first and step as second arg 
+- Constructors should take arg as first and step as second arg
 
 ## Development
 

data/lib/nxt_pipeline.rb

@@ -1,11 +1,12 @@
 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'
-require 'nxt_pipeline/dsl'
 
 module NxtPipeline
 end

data/lib/nxt_pipeline/callbacks.rb

@@ -0,0 +1,58 @@
+module NxtPipeline
+  class Callbacks
+    def initialize(pipeline:)
+      @registry = build_registry
+      @pipeline = pipeline
+    end
+
+    def register(path, callback)
+      registry.resolve!(*path) << callback
+    end
+
+    def run(kind_of_callback, type, change_set)
+      registry.resolve!(kind_of_callback, type).each do |callback|
+        run_callback(callback, change_set)
+      end
+    end
+
+    def around(type, change_set, &execution)
+      around_callbacks = registry.resolve!(:around, type)
+      return execution.call unless around_callbacks.any?
+
+      callback_chain = around_callbacks.reverse.inject(execution) do |previous, callback|
+        -> { callback.call(pipeline, change_set, previous) }
+      end
+
+      callback_chain.call
+    end
+
+    private
+
+    attr_reader :registry, :pipeline
+
+    def run_callback(callback, change_set)
+      args = [pipeline, change_set]
+      args = args.take(callback.arity)
+      callback.call(*args)
+    end
+
+    def build_registry
+      NxtRegistry::Registry.new(:callbacks) do
+        register(:before) do
+          register(:step, [])
+          register(:execution, [])
+        end
+
+        register(:around) do
+          register(:step, [])
+          register(:execution, [])
+        end
+
+        register(:after) do
+          register(:step, [])
+          register(:execution, [])
+        end
+      end
+    end
+  end
+end

data/lib/nxt_pipeline/constructor.rb

@@ -1,13 +1,20 @@
 module NxtPipeline
   class Constructor
-    def initialize(name, opts, block)
+    def initialize(name, **opts, &block)
       @name = name
       @block = block
       @opts = opts
     end
 
     attr_reader :opts, :block
-
-    delegate :call, :arity, to: :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

data/lib/nxt_pipeline/error_callback.rb

@@ -1,7 +1,7 @@
 module NxtPipeline
   class ErrorCallback
-    def initialize(errors, halt_on_error, callback)
-      @errors = errors
+    def initialize(errors, halt_on_error, &callback)
+      @errors = errors.any? ? errors : [StandardError]
       @halt_on_error = halt_on_error
       @callback = callback
     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,68 +23,75 @@ 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 set_default_constructor(name)
+    def step_resolver(&block)
+      step_resolvers << block
+    end
+
+    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(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)
+        # 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)
       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)
+      register_step(argument, constructor, callbacks, **opts)
     end
 
-    def execute(**opts, &block)
+    def execute(**change_set, &block)
       reset
 
       configure(&block) if block_given?
-      before_execute_callback.call(self, opts) if before_execute_callback.respond_to?(:call)
-
-      result = steps.inject(opts) do |options, step|
-        execute_step(step, **options)
-      rescue StandardError => error
-        callback = find_error_callback(error)
-        raise unless callback && callback.continue_after_error?
-        handle_step_error(error)
-        options
+      callbacks.run(:before, :execution, change_set)
+
+      result = callbacks.around :execution, change_set do
+        steps.inject(change_set) do |set, step|
+          execute_step(step, **set)
+        rescue StandardError => error
+          decorate_error_with_details(error, set, step, logger)
+          handle_error_of_step(error)
+          set
+        end
       end
 
-      after_execute_callback.call(self, result) if after_execute_callback.respond_to?(:call)
+      callbacks.run(:after, :execution, change_set)
       result
     rescue StandardError => error
       handle_step_error(error)
     end
 
+    alias_method :call, :execute
+
     def handle_step_error(error)
       log_step(current_step)
       callback = find_error_callback(error)
@@ -94,40 +102,58 @@ module NxtPipeline
     end
 
     def on_errors(*errors, halt_on_error: true, &callback)
-      error_callbacks << ErrorCallback.new(errors, halt_on_error, callback)
+      error_callbacks << ErrorCallback.new(errors, halt_on_error, &callback)
     end
 
     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 after_execute(&callback)
-      self.after_execute_callback = callback
+    def around_step(&block)
+      callbacks.register([:around, :step], block)
+    end
+
+    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, :registry
+    def callbacks
+      @callbacks ||= NxtPipeline::Callbacks.new(pipeline: self)
+    end
+
+    attr_reader :error_callbacks, :constructors, :step_resolvers
     attr_accessor :current_step,
                   :current_arg,
-                  :default_constructor_name,
-                  :before_execute_callback,
-                  :after_execute_callback
+                  :default_constructor_name
 
     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, **change_set)
       self.current_step = step
-      self.current_arg = opts
-      result = step.execute(**opts)
+      self.current_arg = change_set
+      result = step.execute(**change_set)
       log_step(step)
-      result || opts
+      result || change_set
     end
 
     def find_error_callback(error)
@@ -148,5 +174,34 @@ 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
+
+    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(error)
+      error_callback = find_error_callback(error)
+      raise error unless error_callback.present? && error_callback.continue_after_error?
+
+      log_step(current_step)
+      raise error unless error_callback.present?
+
+      error_callback.call(current_step, current_arg, error)
+    end
   end
 end

data/lib/nxt_pipeline/step.rb

@@ -1,50 +1,96 @@
 module NxtPipeline
   class Step
-    def initialize(type, constructor, index, **opts)
+    def initialize(argument, constructor, index, pipeline, callbacks, **opts)
       define_attr_readers(opts)
 
-      @type = type
+      @pipeline = pipeline
+      @callbacks = callbacks
+      @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,
+      :execution_started_at,
+      :execution_finished_at,
+      :execution_duration,
+      :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]
-      if_guard_args = guard_args.take(if_guard.arity)
-      unless_guard_guard_args = guard_args.take(unless_guard.arity)
+    def execute(**change_set)
+      track_execution_time do
+        set_mapped_options(change_set)
+        guard_args = [change_set, self]
 
-      if !unless_guard.call(*unless_guard_guard_args) && if_guard.call(*if_guard_args)
-        self.result = constructor.call(self, **opts)
-      end
+        callbacks.run(:before, :step, change_set)
+
+        if evaluate_unless_guard(guard_args) && evaluate_if_guard(guard_args)
+          callbacks.around(:step, change_set) do
+            set_result(change_set)
+          end
+        end
 
-      set_status
-      result
+        callbacks.run(:after, :step, change_set)
+
+        set_status
+        result
+      end
     rescue StandardError => e
       self.status = :failed
       self.error = e
       raise
     end
 
-    def type?(potential_type)
-      type.to_sym == potential_type.to_sym
+    def set_mapped_options(change_set)
+      mapper = options_mapper || default_options_mapper
+      mapper_args = [change_set, self].take(mapper.arity)
+      self.mapped_options = mapper.call(*mapper_args)
     end
 
     private
 
-    attr_writer :result, :status, :error
-    attr_reader :constructor
+    attr_writer :result, :status, :error, :mapped_options, :execution_started_at, :execution_finished_at, :execution_duration
+    attr_reader :constructor, :options_mapper, :pipeline, :callbacks
+
+    def evaluate_if_guard(args)
+      execute_callable(if_guard, args)
+    end
+
+    def evaluate_unless_guard(args)
+      !execute_callable(unless_guard, args)
+    end
+
+    def set_result(change_set)
+      args = [self, change_set]
+      self.result = execute_callable(constructor, args)
+    end
+
+    def execute_callable(callable, args)
+      args =  args.take(callable.arity)
+
+      if args.last.is_a?(Hash)
+        callable.call(*args.take(args.length - 1), **args.last)
+      else
+        callable.call(*args)
+      end
+    end
 
     def if_guard
       opts.fetch(:if) { guard(true) }
@@ -69,5 +115,30 @@ module NxtPipeline
     def set_status
       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
+      ->(_) { {} }
+    end
   end
 end

data/lib/nxt_pipeline/version.rb

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

data/nxt_pipeline.gemspec

@@ -35,9 +35,10 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
 
   spec.add_dependency "activesupport"
-  spec.add_development_dependency "bundler", "~> 1.17"
+  spec.add_dependency "nxt_registry"
+  spec.add_development_dependency "bundler", "~> 2.1"
   spec.add_development_dependency "guard-rspec"
-  spec.add_development_dependency "rake", "~> 12.3"
+  spec.add_development_dependency "rake", "~> 13.0"
   spec.add_development_dependency "rspec", "~> 3.0"
-  spec.add_development_dependency "pry"
+  spec.add_development_dependency "pry-byebug"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: nxt_pipeline
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 1.0.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: 2021-01-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -26,20 +26,34 @@ 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
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.17'
+        version: '2.1'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.17'
+        version: '2.1'
 - !ruby/object:Gem::Dependency
   name: guard-rspec
   requirement: !ruby/object:Gem::Requirement
@@ -60,14 +74,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '12.3'
+        version: '13.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '12.3'
+        version: '13.0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -83,7 +97,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '3.0'
 - !ruby/object:Gem::Dependency
-  name: pry
+  name: pry-byebug
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -105,6 +119,7 @@ extra_rdoc_files: []
 files:
 - ".circleci/config.yml"
 - ".gitignore"
+- ".pryrc"
 - ".rspec"
 - ".ruby-version"
 - ".travis.yml"
@@ -120,8 +135,8 @@ files:
 - bin/rspec
 - bin/setup
 - lib/nxt_pipeline.rb
+- lib/nxt_pipeline/callbacks.rb
 - lib/nxt_pipeline/constructor.rb
-- lib/nxt_pipeline/dsl.rb
 - lib/nxt_pipeline/error_callback.rb
 - lib/nxt_pipeline/logger.rb
 - lib/nxt_pipeline/pipeline.rb
@@ -150,7 +165,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.1.2
 signing_key: 
 specification_version: 4
 summary: DSL to build Pipeline with mountable Segments to process things.

data/lib/nxt_pipeline/dsl.rb

@@ -1,44 +0,0 @@
-module NxtPipeline
-  module Dsl
-    module ClassMethods
-      def pipeline(name = :default, &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
-      end
-
-      def pipeline!(name, &block)
-        raise ArgumentError, "No block given!" unless block_given?
-        pipeline_registry[name] = block
-      end
-
-      private
-
-      def inherited(child)
-        child.instance_variable_set(:@pipeline_registry, pipeline_registry.clone)
-      end
-
-      def raise_already_registered_error(name)
-        raise KeyError, "Already registered a pipeline #{name}. Call pipeline! to overwrite already registered pipelines"
-      end
-
-      def pipeline_registry
-        @pipeline_registry ||= ActiveSupport::HashWithIndifferentAccess.new
-      end
-    end
-
-    def self.included(base)
-      base.extend(ClassMethods)
-
-      def pipeline(name = :default)
-        self.class.pipeline(name)
-      end
-    end
-  end
-end