simple_pipeline 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d7498222868fb61586a42e233b459aed023f91a4
-  data.tar.gz: 157c751b613f41bd2b0a507606a4ed2be6b5538b
+  metadata.gz: c4919357b1935895facfb4607f74def1253c1dea
+  data.tar.gz: 5dace42d21950ae0f05c21d39d338d09f58d0d2d
 SHA512:
-  metadata.gz: e86424d591224a4bd4e0822666c83877f0fa497d33c570989748329c007842e8d7c3f7d7861262a75a1b01252014f838bc2d9bee772a459a2d22107b13b9b689
-  data.tar.gz: 2d6b0b662fd764343825ca652469940879e270434d4b0a7f8185aa8d74e988bd8f60dfbf73bf57fe4a620c937e0d8e22183629adae1676c2faba1448053c37c4
+  metadata.gz: 51a6fe55e765bd7d78114cc8d3d77aa7eaac165105292e79e57f64f6d80367b7de3173e25591244b4aa9412d0c38ffc88e24926446a2865d037f4efff2bc6f9e
+  data.tar.gz: 6fa5f5a13a1834194fda4cbef8701c80be10817c648d3f97c1d6a5d51417f5b35e247a3d2f6f9a5c54ee1d59085574302976ef19049e75418fa20a9c8572046b

data/README.md

@@ -1,31 +1,94 @@
-# SimplePipeline
-
-TODO: Write a gem description
-
-## Installation
-
-Add this line to your application's Gemfile:
-
-```ruby
-gem 'simple_pipeline'
-```
-
-And then execute:
-
-    $ bundle
-
-Or install it yourself as:
-
-    $ gem install simple_pipeline
-
-## Usage
-
-TODO: Write usage instructions here
-
-## Contributing
-
-1. Fork it ( https://github.com/[my-github-username]/simple_pipeline/fork )
-2. Create your feature branch (`git checkout -b my-new-feature`)
-3. Commit your changes (`git commit -am 'Add some feature'`)
-4. Push to the branch (`git push origin my-new-feature`)
-5. Create a new Pull Request
+# SimplePipeline
+
+**SimplePipeline** is a simple framework for sequentially executing a series of code components. Each code component takes a payload, modifies it, and moves it down the pipe for the next component and so forth. One of the design goals is to make it as flexible as possible, yet keep it simple.
+
+## Installation
+
+Install the gem from RubyGems:
+
+```bash
+gem install simple_pipeline
+```
+
+If you use Bundler, just add it to your Gemfile and run `bundle install`
+
+```ruby
+gem 'simple_pipeline'
+```
+
+I have only tested this gem on Ruby 2.3.0, but there shouldn't be any reason why it wouldn't work on earlier Ruby versions as well.
+
+## Usage
+
+```ruby
+pipeline = SimplePipeline.new
+
+pipeline.add Pipe1.new
+pipeline.add Pipe2.new
+pipeline.add Pipe3.new
+        
+payload = {:some_key => some_value}
+
+pipeline.process payload
+```
+
+**SimplePipeline** will call the ```process``` method on each of the pipes in the order that they were added to the pipeline.
+
+## Pipes
+
+A **pipe** can be any Ruby object that has a ```process``` method that accepts a single argument (the payload object). For example:
+
+```ruby
+class Pipe1
+    def process (payload)
+        # Do something with the payload object
+    end
+end
+```
+
+## Payload
+
+The **payload** can be an Array, Hash, or any other Ruby object. Individual pipes have the responsibility to know what to do with the payload that is passed into the ```process``` method.
+
+## Timeout
+
+You can use the **SimplePipeline::Timeout** mixin to enforce a timeout value (in seconds) for a pipe. If the execution of the ```process``` method exceeds the specified timeout value, a ```Timeout::Error``` will be thrown.
+
+```ruby
+class TimeoutPipe
+    include SimplePipeline::Timeout
+
+    set_timeout 3 # Set the timeout value to be three seconds
+
+    def process (payload)
+        # Do something
+    end
+end
+
+pipeline = SimplePipeline.new
+pipeline.add TimeoutPipe.new
+
+payload = {:some_key => some_value}
+
+# Will throw a Timeout::Error if execution of process on the TimeoutPipe instance takes longer than 3 seconds
+pipeline.process payload
+```
+
+You can also set the timeout value on a per instance basis.
+
+```ruby
+pipeline = SimplePipeline.new
+
+pipe1 = TimeoutPipe.new
+pipe1.set_timeout 10
+
+pipe2 = TimeoutPipe.new
+pipe2.set_timeout 60
+
+pipeline.add pipe1
+pipeline.add pipe2
+```
+This will override the timeout value set by the class definition.
+
+## License
+**SimplePipeline** is released under the [MIT license](MIT-LICENSE).

data/lib/simple_pipeline.rb

@@ -3,35 +3,33 @@ require "simple_pipeline/version"
 
 
 class SimplePipeline
-
-	def initialize
-		@pipes = []
-	end
-
-	def add (pipe)
-		begin
-			raise ArgumentError, "invalid pipe - incorrect number of arguments for process() method (should be 1)" unless pipe.class.instance_method(:process).arity == 1
-		rescue NameError
-			raise ArgumentError, "invalid pipe - process() method not found"
-		end
-
-		@pipes << pipe
-	end
-
-	def size
-		return @pipes.size
-	end
-
-	def process (payload)
-		@pipes.each do |pipe|
-			if pipe.is_a? SimplePipeline::Timeout
-				pipe.process_with_timeout(payload)
-			else
-				pipe.process(payload)
-			end
-		end
-	end
-
-	alias :length :size
-
+    def initialize
+        @pipes = []
+    end
+
+    def add (pipe)
+        begin
+            raise ArgumentError, "invalid pipe - incorrect number of arguments for process() method (should be 1)" unless pipe.class.instance_method(:process).arity == 1
+        rescue NameError
+            raise ArgumentError, "invalid pipe - process() method not found"
+        end
+
+        @pipes << pipe
+    end
+
+    def size
+        return @pipes.size
+    end
+
+    def process (payload)
+        @pipes.each do |pipe|
+            if pipe.is_a? SimplePipeline::Timeout
+                pipe.process_with_timeout(payload)
+            else
+                pipe.process(payload)
+            end
+        end
+    end
+
+    alias :length :size
 end

data/lib/simple_pipeline/timeout.rb

@@ -1,19 +1,30 @@
 require 'timeout'
 
 class SimplePipeline
+    module Timeout
+        def self.included (base)
+            base.extend(ClassMethods)
+            base.class_variable_set(:@@timeout_in_sec, 0)
+        end
 
-	module Timeout
+        module ClassMethods
+            def set_timeout (sec)
+                self.class_variable_set(:@@timeout_in_sec, sec)
+            end
+        end
 
-		def set_timeout (sec)
-			@timeout_in_sec = sec
-		end
+        def timeout=(sec)
+            @timeout_in_sec = sec
+        end
 
-		def process_with_timeout (payload)
-			::Timeout::timeout(@timeout_in_sec) {
-				process(payload)
-			}
-		end
-
-	end
+        def process_with_timeout (payload)
+            ::Timeout::timeout(timeout) {
+                process(payload)
+            }
+        end
 
+        def timeout
+            @timeout_in_sec || self.class.class_variable_get(:@@timeout_in_sec)
+        end
+    end
 end

data/lib/simple_pipeline/version.rb

@@ -1,3 +1,3 @@
 class SimplePipeline
-  VERSION = "0.0.2"
+    VERSION = "0.0.3"
 end

data/spec/simple_pipeline_spec.rb

@@ -1,63 +1,65 @@
 require 'spec_helper'
 
 class TestPipe
-	def process (payload)
-		payload[:test_value] *= 10
-	end
+    def process (payload)
+        payload[:test_value] *= 10
+    end
 end
 
 class BadPipe
-	def process (payload1, payload2)
-		# do nothing
-	end
+    def process (payload1, payload2)
+        # do nothing
+    end
 end
 
 class TimeoutPipe
-	include SimplePipeline::Timeout
+    include SimplePipeline::Timeout
 
-	def initialize
-		set_timeout 1 # seconds
-	end
+    set_timeout 3 # seconds
 
-	def process (payload)
-		sleep 10 # seconds
-	end
+    def process (payload)
+        sleep 10 # seconds
+    end
 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
-		
-		payload = {:test_value => 10}
-
-		pipeline.process(payload)
-
-		expect(pipeline.size).to eq 3
-    	expect(payload[:test_value]).to eq 10000
-  	end
-
-  	it "should throw an error for invalid pipes" do
-		pipeline = SimplePipeline.new
-		
-		expect {
-			pipeline.add Object.new # not a pipe
-		}.to raise_error(ArgumentError)
-
-		expect {
-			pipeline.add BadPipe
-		}.to raise_error(ArgumentError)
-	end
-
-	it "should support pipes with timeout" do
-		pipeline = SimplePipeline.new
-		pipe = TimeoutPipe.new
-		pipeline.add pipe
-
-		expect {
-			pipeline.process({})
-		}.to raise_error(Timeout::Error)
-	end
+    it "should support three normal pipes" do
+        pipeline = SimplePipeline.new
+        pipeline.add TestPipe.new
+        pipeline.add TestPipe.new
+        pipeline.add TestPipe.new
+        
+        payload = {:test_value => 10}
+
+        pipeline.process(payload)
+
+        expect(pipeline.size).to eq 3
+        expect(payload[:test_value]).to eq 10000
+    end
+
+    it "should throw an error for invalid pipes" do
+        pipeline = SimplePipeline.new
+        
+        expect {
+            pipeline.add Object.new # not a pipe
+        }.to raise_error(ArgumentError)
+
+        expect {
+            pipeline.add BadPipe
+        }.to raise_error(ArgumentError)
+    end
+
+    it "should support pipes with timeout" do
+        pipeline = SimplePipeline.new
+        pipe = TimeoutPipe.new
+        pipeline.add pipe
+
+        expect(pipe.timeout).to eq 3
+        pipe.timeout = 1
+        expect(pipe.timeout).to eq 1
+
+        expect {
+            pipeline.process({})
+        }.to raise_error(Timeout::Error)
+    end
 end

metadata

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