nxt_pipeline 0.2.4 → 0.2.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6b545c68dc71684330edc75197b306a9f87abfb90240efe4708d426299902782
-  data.tar.gz: d47d498587927798476462538f3c42ea7a151080fe6cdbdccd56e0e12baa9d05
+  metadata.gz: 7aa1fdbbfb4c1d0eb99c72270cf13893f34fda78162abb749091600b1857f8bb
+  data.tar.gz: adce759515d5d7ee687eaf96221083127e089946945095d8ddf931348f4d4826
 SHA512:
-  metadata.gz: ddfe39ac16d28a562a28f42e41205828f8ffe8c448b8135e798aecfd71a2083870e4faffc7e5fc0f1e19625d63eaf0f2930e1b2fbc21a6cb68987647446ae5de
-  data.tar.gz: 76ef2fc1b046dac15ed2c5f913048ea304b9ceddcfcd7f6777b9a623026d87e49322ecae0219ce35813b86aabf30867debb667ec69157adebd1adfd0620e6b53
+  metadata.gz: f3a040fe24d3e4329d7241eba0d21c49f0696027bf8e39550a7cf473c3a80e7b86f1313a00fe4c78feac2a6621f8a6b55d7f6e05eadd0a674b5782bb70e8d3f2
+  data.tar.gz: a9e3ad99022ef92321e680e664207f296bd69f9ffe2f12edb8193f129e102fe4bc0b52363af769b4408ed36dcec8a29329bfedf0da06f28ae2c5929e54850a02

data/README.md

@@ -76,7 +76,9 @@ pipeline.step to_s: 'This is the same as above' do |step, arg|
 end
 ```
 
-You can also define inline steps, meaning the block will be executed
+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. 
 
 ### Execution
 
@@ -106,6 +108,13 @@ NxtPipeline::Pipeline.execute('initial argument') do |p|
 end
 ``` 
 
+You can query the steps of your pipeline simply by calling `pipeline.steps`. A NxtPipeline::Step will provide you with 
+an interface it's type, options, status (:success, :skipped, :failed), result, error and the index in the pipeline.
+
+```
+pipeline.steps.first 
+``` 
+
 ### Error callbacks
 
 Apart from defining constructors and steps you can also define error callbacks.

data/lib/nxt_pipeline/logger.rb

@@ -0,0 +1,13 @@
+module NxtPipeline
+  class Logger
+    def initialize
+      @log = {}
+    end
+
+    attr_accessor :log
+
+    def call(step)
+      log[step.to_s] = step.status
+    end
+  end
+end

data/lib/nxt_pipeline/pipeline.rb

@@ -7,15 +7,18 @@ module NxtPipeline
     def initialize(&block)
       @steps = []
       @error_callbacks = []
-      @log = {}
+      @logger = Logger.new
       @current_step = nil
       @current_arg = nil
-      @default_constructor = nil
+      @default_constructor_name = nil
       @registry = {}
+
       configure(&block) if block_given?
     end
 
-    attr_reader :log
+    alias_method :configure, :tap
+
+    attr_accessor :logger, :steps
 
     # register steps with name and block
     def constructor(name, **opts, &constructor)
@@ -25,39 +28,60 @@ module NxtPipeline
       registry[name] = constructor
 
       return unless opts.fetch(:default, false)
-      default_constructor ? (raise ArgumentError, 'Default step already defined') : self.default_constructor = constructor
+      set_default_constructor(name)
+    end
+
+    def set_default_constructor(name)
+      raise_duplicate_default_constructor if default_constructor_name.present?
+      self.default_constructor_name = name
+    end
+
+    def raise_duplicate_default_constructor
+      raise ArgumentError, 'Default step already defined'
     end
 
     def step(type = nil, **opts, &block)
+      type = type&.to_sym
+
       constructor = if block_given?
-        # make first argument the to_s of step if given
-        opts.merge!(to_s: type) if type && !opts.key?(:to_s)
+        # 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)
         block
       else
         if type
+          raise_reserved_type_inline_error if type == :inline
           registry.fetch(type) { raise KeyError, "No step :#{type} registered" }
         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')
         end
       end
 
-      steps << Step.new(constructor, **opts)
+      steps << Step.new(type, constructor, steps.count, **opts)
     end
 
     def execute(arg, &block)
-      reset_log
-      before_execute_callback.call(self, arg) if before_execute_callback.respond_to?(:call)
+      reset
+
       configure(&block) if block_given?
+      before_execute_callback.call(self, arg) if before_execute_callback.respond_to?(:call)
+
       result = steps.inject(arg) do |argument, step|
         execute_step(step, argument)
       end
+
       after_execute_callback.call(self, result) if after_execute_callback.respond_to?(:call)
       result
     rescue StandardError => error
-      log[current_step] = { status: :failed, reason: "#{error.class}: #{error.message}" }
+      log_step(current_step)
       callback = find_error_callback(error)
 
       raise unless callback
+
       callback.call(current_step, current_arg, error)
     end
 
@@ -75,38 +99,46 @@ module NxtPipeline
       self.after_execute_callback = callback
     end
 
-    def configure(&block)
-      block.call(self)
-      self
-    end
-
     private
 
     attr_reader :error_callbacks, :registry
-    attr_accessor :steps, :current_step, :current_arg, :default_constructor, :before_execute_callback, :after_execute_callback
-    attr_writer :log
+    attr_accessor :current_step,
+                  :current_arg,
+                  :default_constructor_name,
+                  :before_execute_callback,
+                  :after_execute_callback
+
+    def default_constructor
+      return unless default_constructor_name
+
+      @default_constructor ||= registry[default_constructor_name.to_sym]
+    end
 
     def execute_step(step, arg)
-      self.current_step = step.to_s
+      self.current_step = step
       self.current_arg = arg
       result = step.execute(arg)
-
-      if result # step was successful
-        log[current_step] = { status: :success }
-        result
-      else # step was not successful if nil or false
-        log[current_step] = { status: :skipped }
-        arg
-      end
+      log_step(step)
+      result || arg
     end
 
     def find_error_callback(error)
       error_callbacks.find { |callback| callback.applies_to_error?(error) }
     end
 
-    def reset_log
-      self.log = {}
+    def log_step(step)
+      return unless logger.respond_to?(:call)
+
+      logger.call(step)
+    end
+
+    def reset
       self.current_arg = nil
+      self.current_step = nil
+    end
+
+    def raise_reserved_type_inline_error
+      raise ArgumentError, 'Type :inline is reserved for inline steps!'
     end
   end
 end

data/lib/nxt_pipeline/step.rb

@@ -1,25 +1,41 @@
 module NxtPipeline
   class Step
-    def initialize(constructor, **opts)
+    def initialize(type, constructor, index, **opts)
       define_attr_readers(opts)
+
+      @type = type
+      @index = index
+      @result = nil
       @opts = opts
+      @status = nil
       @constructor = constructor
+      @error = nil
     end
 
-    attr_accessor :constructor
+    attr_reader :type, :result, :status, :error, :opts, :index
 
     def execute(arg)
-      constructor.call(self, arg)
-      # instance_exec(arg, &constructor)
+      self.result = constructor.call(self, arg)
+      set_status
+      result
+    rescue StandardError => e
+      self.status = :failed
+      self.error = e
+      raise
     end
 
     def to_s
-      "#{self.class} opts => #{opts}"
+      "#{opts.merge(type: type)}"
+    end
+
+    def type?(potential_type)
+      type.to_sym == potential_type.to_sym
     end
 
     private
 
-    attr_reader :opts
+    attr_writer :result, :status, :error
+    attr_reader :constructor
 
     def define_attr_readers(opts)
       opts.each do |key, value|
@@ -28,5 +44,9 @@ module NxtPipeline
         end
       end
     end
+
+    def set_status
+      self.status = result.present? ? :success : :skipped
+    end
   end
 end

data/lib/nxt_pipeline/version.rb

@@ -1,3 +1,3 @@
 module NxtPipeline
-  VERSION = "0.2.4".freeze
+  VERSION = "0.2.5".freeze
 end

data/lib/nxt_pipeline.rb

@@ -1,4 +1,6 @@
+require 'active_support/all'
 require 'nxt_pipeline/version'
+require 'nxt_pipeline/logger'
 require 'nxt_pipeline/pipeline'
 require 'nxt_pipeline/step'
 require 'nxt_pipeline/error_callback'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: nxt_pipeline
 version: !ruby/object:Gem::Version
-  version: 0.2.4
+  version: 0.2.5
 platform: ruby
 authors:
 - Nils Sommer
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-06-14 00:00:00.000000000 Z
+date: 2019-06-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -121,6 +121,7 @@ files:
 - bin/setup
 - lib/nxt_pipeline.rb
 - lib/nxt_pipeline/error_callback.rb
+- lib/nxt_pipeline/logger.rb
 - lib/nxt_pipeline/pipeline.rb
 - lib/nxt_pipeline/step.rb
 - lib/nxt_pipeline/version.rb