simple_pipeline 0.0.4 → 0.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: '0841cc3eab093abcc6a954e3d24c1153de824d02'
-  data.tar.gz: 46f0b23b29b62843bbefbe73615ac318c1082214
+  metadata.gz: 677d2ff5729eb15c9fd13f634606d462279001de
+  data.tar.gz: 781a8d2a9772234ce73be2ba1d42c87b75ff6ecc
 SHA512:
-  metadata.gz: dc93171e985aa842a237ddce20c0ab935d5bcb776a63153e3ca6429018435e8cae0dff833641ea6c39b6c6184d838df00d26610707b80acd731ec762cbe20015
-  data.tar.gz: eb66c3a879ef980ab1679a8e6b5150cc9c0680ac85d6664a1f5d255f40e92fa9a051d4771116a9bc956f143c1459c1657c28e478c36125c6356ed3a78486d143
+  metadata.gz: 4545e19ba08add3987a1cd729c478917098d754df9557a3fe79f15309df96fa40a71c4a6ffe9fc5b8f0c20c68bded8a00adb3f7800ebf617ef9d69e8b9499e56
+  data.tar.gz: 84e0c38fa8984b5843c861d6f5fcffd3ed4053cce508273d4b6fb483b680b0045c7c8ef5a0e7a3e85041095bde656f5541eb7d692104ffce20f192af2b770437

data/README.md

@@ -58,7 +58,8 @@ You can use the **SimplePipeline::Timeout** mixin to enforce a timeout value (in
 class TimeoutPipe
     include SimplePipeline::Timeout
 
-    set_timeout 3 # Set the timeout value to be three seconds
+    # Set the timeout value to be 3 seconds
+    set_timeout 3 
 
     def process (payload)
         # Do something
@@ -74,21 +75,48 @@ payload = {:some_key => some_value}
 pipeline.process payload
 ```
 
-You can also set the timeout value on a per instance basis.
+You can also set the timeout value on a per instance basis. This will override the timeout value set by the class definition.
 
 ```ruby
-pipeline = SimplePipeline.new
-
 pipe1 = TimeoutPipe.new
-pipe1.set_timeout 10
+pipe1.set_timeout 10 # seconds
 
 pipe2 = TimeoutPipe.new
-pipe2.set_timeout 60
+pipe2.set_timeout 60 # seconds
 
 pipeline.add pipe1
 pipeline.add pipe2
 ```
-This will override the timeout value set by the class definition.
+
+If you don't want to use the **SimplePipeline::Timeout** mixin for your pipe, you can still set a timeout by passing in a ```:timeout``` value when you are adding the pipe. If you do this, the param value will take precedence over any other timeout value set by the mixin.
+
+```ruby
+# Timeout value set to 10 seconds, even though SomePipe doesn't include SimplePipeline::Timeout
+pipeline.add SomePipe.new, :timeout => 10 
+
+# Timeout value set to 10 seconds, even though TimeoutPipe defaults to a timeout of 3 seconds
+pipeline.add TimeoutPipe.new, :timeout => 10 
+```
+
+## Exception Handling
+
+By default, execution of the entire pipeline will halt if any of the pipes raise a ```StandardError```. However, this can be overriden using the ```:continue_on_error?``` parameter.
+
+```ruby
+# Pipeline continues executing if any kind of StandardError is encountered
+pipeline.add pipe, :continue_on_error? => true
+
+# Pipeline continues executing if NameError or subclass (e.g. NoMethodError) is encountered
+pipeline.add pipe, :continue_on_error? => NameError
+
+# Pipeline continues executing on either ArgumentError or NameError (or subclass)
+pipeline.add pipe, :continue_on_error? => [ArgumentError, NameError]
+
+# Pipeline continues executing if any kind of Exception is encountered - not recommended
+pipeline.add pipe, :continue_on_error? => Exception
+```
+
+After the pipeline finishes executing, you can call ```pipeline.errors``` to get an Array of errors that were caught during execution.
 
 ## Related Projects
 

data/lib/simple_pipeline/version.rb

@@ -1,3 +1,3 @@
 class SimplePipeline
-    VERSION = "0.0.4"
+    VERSION = "0.0.5"
 end

data/lib/simple_pipeline.rb

@@ -12,15 +12,17 @@ class SimplePipeline
         @errors = []
     end
 
-    def add (pipe, args = {})
+    def add (pipe, params = {})
+        process_method = params[:process_method] || :process 
+
         begin
-            raise ArgumentError, "invalid pipe - incorrect number of arguments for process() method (should be 1)" unless pipe.class.instance_method(:process).arity == 1
+            raise ArgumentError, "invalid pipe - incorrect number of arguments for #{process_method}() method (should be 1)" unless pipe.class.instance_method(process_method).arity == 1
         rescue NameError
-            raise ArgumentError, "invalid pipe - process() method not found"
+            raise ArgumentError, "invalid pipe - #{process_method}() method not found"
         end
 
         @pipe_order << pipe
-        @pipe_config[pipe] = args
+        @pipe_config[pipe] = params
 
         return pipe
     end
@@ -32,19 +34,9 @@ class SimplePipeline
     def process (payload)
         @pipe_order.each do |pipe|
             begin
-                timeout = @pipe_config[pipe][:timeout]
-
-                if timeout.nil? && (pipe.is_a? SimplePipeline::Timeout)
-                    timeout = pipe.timeout
-                end
-
-                if timeout.nil?
-                    pipe.process(payload)
-                else
-                    process_with_timeout(pipe, payload, timeout)                    
-                end
+                invoke_process_with_timeout(pipe, payload, get_timeout(pipe))
             rescue
-                raise $! unless continue_on_error?($!, @pipe_config[pipe][:continue_on_error?])
+                raise $! unless continue_on_error?($!, pipe)
                 @errors << $!
             end
         end
@@ -54,7 +46,9 @@ class SimplePipeline
 
     private
 
-    def continue_on_error? (e, config_value)
+    def continue_on_error? (e, pipe)
+        config_value = @pipe_config[pipe][:continue_on_error?]
+
         return false if config_value.nil? || config_value == false
         return true if config_value == true
         
@@ -69,10 +63,19 @@ class SimplePipeline
         return false
     end
 
-
-    def process_with_timeout (pipe, payload, timeout)
+    def invoke_process_with_timeout (pipe, payload, timeout)
         ::Timeout::timeout(timeout) {
-            pipe.process(payload)
+            pipe.__send__(get_process_method(pipe), payload)
         }
     end
+
+    def get_process_method (pipe)
+        @pipe_config[pipe][:process_method] || :process
+    end
+
+    def get_timeout (pipe)
+        timeout = @pipe_config[pipe][:timeout]
+        timeout = pipe.timeout if timeout.nil? && (pipe.is_a? SimplePipeline::Timeout)
+        return timeout 
+    end
 end

data/spec/simple_pipeline_spec.rb

@@ -1,18 +1,22 @@
 require 'spec_helper'
 
-class TestPipe
+class TestPipe1
     def process (payload)
         payload[:test_value] *= 10
     end
 end
 
-class BadPipe
+class TestPipe2
     def process (payload1, payload2)
         # do nothing
     end
+
+    def alternate_process_method (payload)
+        payload[:test_value] *= 10
+    end
 end
 
-class TimeoutPipe
+class TimeoutPipe1
     include SimplePipeline::Timeout
 
     set_timeout 3 # seconds
@@ -37,9 +41,9 @@ end
 describe SimplePipeline do
     it "should support three normal pipes" do
         pipeline = SimplePipeline.new
-        pipeline.add TestPipe.new
-        pipeline.add TestPipe.new
-        pipeline.add TestPipe.new
+        pipeline.add TestPipe1.new
+        pipeline.add TestPipe1.new
+        pipeline.add TestPipe1.new
         
         payload = {:test_value => 10}
 
@@ -57,13 +61,13 @@ describe SimplePipeline do
         }.to raise_error(ArgumentError)
 
         expect {
-            pipeline.add BadPipe
+            pipeline.add TestPipe2.new
         }.to raise_error(ArgumentError)
     end
 
     it "should support pipes with timeout values" do
         pipeline = SimplePipeline.new
-        pipe = TimeoutPipe.new
+        pipe = TimeoutPipe1.new
         pipeline.add pipe
 
         expect(pipe.timeout).to eq 3
@@ -82,11 +86,11 @@ describe SimplePipeline do
         }.to raise_error(Timeout::Error)
     end
 
-    it "should support pipes with continue_on_error => true" do
+    it "should support pipes with :continue_on_error" do
         pipeline = SimplePipeline.new
-        pipeline.add TestPipe.new
+        pipeline.add TestPipe1.new
         pipeline.add ExceptionPipe.new
-        pipeline.add TestPipe.new
+        pipeline.add TestPipe1.new
 
         payload = {:test_value => 10}
 
@@ -98,13 +102,13 @@ describe SimplePipeline do
         expect(pipeline.errors.size).to eq 0
 
         pipeline = SimplePipeline.new
-        pipeline.add TestPipe.new
+        pipeline.add TestPipe1.new
         pipeline.add ExceptionPipe.new, :continue_on_error? => true
         pipeline.add ExceptionPipe.new, :continue_on_error? => ArgumentError
         pipeline.add ExceptionPipe.new, :continue_on_error? => StandardError
         pipeline.add ExceptionPipe.new, :continue_on_error? => [ArgumentError]
         pipeline.add ExceptionPipe.new, :continue_on_error? => [RuntimeError, StandardError]
-        pipeline.add TestPipe.new
+        pipeline.add TestPipe1.new
 
         payload = {:test_value => 10}
 
@@ -113,4 +117,19 @@ describe SimplePipeline do
         expect(payload[:test_value]).to eq 1000
         expect(pipeline.errors.size).to eq 5
     end
+
+    it "should support pipes with :process_method" do
+        pipeline = SimplePipeline.new
+        pipeline.add TestPipe2.new, :process_method => :alternate_process_method
+        
+        expect {
+            pipeline.add TestPipe1.new, :process_method => :this_method_doesnt_exist
+        }.to raise_error(ArgumentError)
+
+        payload = {:test_value => 10}
+
+        pipeline.process(payload)
+
+        expect(payload[:test_value]).to eq 100
+    end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: simple_pipeline
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.0.5
 platform: ruby
 authors:
 - Jonathan Wong
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-07-04 00:00:00.000000000 Z
+date: 2016-07-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec