pipeliner 1.0

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2009 spox <spox@modspox.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,112 @@
+== Pipeliner
+
+The pipeliner library provides framework for message passing between objects. It allows objects to hook into the pipeline to receive certain types of objects, and process them in any way they see fit. Processing happens using a thread pool, letting message processing happen in an asynchronous fashion.
+
+=== install (easy):
+
+    gem install pipeliner
+
+=== install (less easy):
+
+    git clone http://github.com/spox/pipeliner.git
+    cd pipeliner && gem build *.gemspec && gem install ./
+
+=== install (less easy that's a little easier)
+
+{rip}[http://hellorip.com/about.html] makes it easy to install directly from a github repository.
+
+== Gritty Details
+
+The pipeliner library allows for some fun things, and here is where I'll try and explain some of them. First, lets take a look at a simple example of this library in action:
+
+    require 'pipeliner'
+
+    output = Array.new
+    pipeline = Pipeliner::Pipeline.new
+    pipeline.hook(String){|s| output << "#{s}: modified"}
+    pipeline << "string"
+    pipeline << 100
+    p output
+
+    => ["string: modified"]
+
+In the example above, we use a simple block to process any String type objects. Anything else passed placed in the pipeline is ignored by the block. We can also use objects instead of blocks:
+
+    require 'pipeliner'
+
+    class Tester < Pipeliner::Filter
+        attr_reader :store
+        def initialize
+            @store = []
+        end
+        def process(m)
+            @store << m
+        end
+    end
+
+    pipeline = Pipeliner::Pipeline.new
+    obj = Tester.new
+    pipeline.hook(Object, obj, :process)
+    pipeline << "String"
+    pipeline << 100
+    pipeline << {:test => :data}
+    p obj.store
+
+    => ["String", 100, {:test=>:data}]
+
+But, what if you want anything added to the pipeline to be modified before it is distributed out to hooked processors? Well, then you would use a filter:
+
+    require 'pipeliner'
+
+    output = []
+    pipeline = Pipeliner::Pipeline.new
+    pipeline.filters.add(String){|s| "#{s} -> filtered"}
+    pipeline.hook(Object){|s| output << s}
+    pipeline << "string"
+    p output
+
+    => ["string -> filtered"]
+
+Filters allow objects to be modified before reaching any hooked processors, and can even remove an unwanted object from the pipeline. Here is an example that removes all Symbols:
+
+    require 'pipeliner'
+
+    output = []
+    pipeline = Pipeliner::Pipeline.new
+    pipeline.filters.add(Symbol){|s| nil}
+    pipeline.hook(Object){|s| output << s}
+    pipeline << "string"
+    pipeline << 100
+    pipeline << :test
+    p output
+
+    => ["string", 100]
+
+Filters can also be created using the Filter object:
+
+    require 'pipeliner'
+
+    class MyFilter < Pipeliner::Filter
+        def do_filter(m)
+            "#{m} - filtered"
+        end
+    end
+    output = []
+    pipeline = Pipeliner::Pipeline.new
+    filter = MyFilter.new(String)
+    pipeline.filters.add(String, filter)
+    pipeline.hook(Object){|s|output << s}
+    pipeline << "string"
+    pipeline << 100
+    p output
+
+    => ["string - filtered", 100]
+
+== Last remarks
+
+If you find any bugs, please report them through {github}[http://github.com/spox/pipeliner/issues]. If you are in need of any help, you can generally find me on DALnet and Freenode.
+
+== License
+
+    Pipeliner is licensed under the MIT License
+    Copyright (c) 2009 spox <spox@modspox.com>

data/lib/pipeliner/Filter.rb

@@ -0,0 +1,31 @@
+module Pipeliner
+    class Filter
+        # type of Objects filter is to be applied to
+        attr_reader :type
+        # t:: type of Objects filter is to be applied to
+        # Create a new Filter
+        def initialize(t)
+            raise ArgumentError.new('Expecting Class or String') unless [Class, String].include?(t.class)
+            @type = t
+        end
+
+        # o:: Object from Pipeline
+        # Applies filter to Object
+        def filter(o)
+            raise ArgumentError.new('Wrong type supplied to filter') unless Splib.type_of?(o, @type)
+            do_filter(o)
+        end
+
+        protected
+
+        # o:: Object to be filtered
+        # This is where the actual filtering takes place. This
+        # is the method to overload!
+        # NOTE: Objects can be filtered in any way. For a filter to
+        # basically "throw away" an Object, simply return nil and the
+        # Object will not be flushed down the Pipeline
+        def do_filter(o)
+            raise NoMethodError.new('This method has not been implemented')
+        end
+    end
+end

data/lib/pipeliner/FilterManager.rb

@@ -0,0 +1,109 @@
+require 'pipeliner/Filter'
+require 'thread'
+
+module Pipeliner
+    class FilterManager
+        # Create a new FilterManager
+        def initialize
+            @filters = {}
+            @lock = Mutex.new
+        end
+
+        # type:: Object type to apply filter to
+        # filter:: Pipeline::Filter to add
+        # Add a Filter to be applied to the given types
+        def add(type, filter=nil, &block)
+            if((filter.nil? && !block_given?) || (filter && !filter.is_a?(Filter)))
+                raise ArgumentError.new('Filter or proc must be provided for filter')
+            end
+            const = Splib.find_const(type)
+            type = const unless const.nil?
+            @lock.synchronize do
+                @filters[type] ||= {}
+            end
+            if(block_given?)
+                unless(block.arity == 1 || block.arity < 0)
+                    raise ArgumentError.new('Block must accept a parameter')
+                end
+                @lock.synchronize do
+                    @filters[type][:procs] ||= []
+                    unless(@filters[type][:procs].include?(block))
+                        @filters[type][:procs] << block
+                    end
+                end
+            end
+            if(filter)
+                @lock.synchronize do
+                    unless(@filters[type].include?(filter))
+                        @filters[type][:filters] ||= []
+                        unless(@filters[type][:filters].include?(filter))
+                            @filters[type][:filters] << filter
+                        end
+                    end
+                end
+            end
+            filter ? block_given? ? [filter, block] : filter : block
+        end
+
+        # filter:: Pipeline::Filter to remove
+        # type:: Object type filter is applied to. 
+        # Remove Filter from given type. If no type is given all references
+        # to the given filter will be removed
+        def remove(filter, type=nil)
+            if(type)
+                const = Splib.find_const(type)
+                type = const unless const.nil?
+            end
+            @lock.synchronize do
+                (type ? [@filters[type]] : @filters.values).each do |set|
+                    [:filters, :procs].each do |t|
+                        if(set[t])
+                            set[t].delete_if{|v| v == filter}
+                            set.delete(t) if set[t].empty?
+                        end
+                    end
+                end
+                @filters.delete_if{|k,v|v.empty?}
+            end
+            nil
+        end
+
+        # type:: Object types
+        # Return filters of given type or all filters
+        # if not type is supplied
+        def filters(type=nil)
+            unless(type)
+                @filters.dup
+            else
+                const = Splib.find_const(type)
+                type = const unless const.nil?
+                @filters[type] ? @filters[type].dup : nil
+            end
+        end
+
+        # o:: Object to apply filters to
+        # Applies any Filters applicable to object type
+        def apply_filters(o)
+            @filters.keys.find_all{|type| Splib.type_of?(o, type)}.each do |type|
+                @filters[type].each_pair do |k,v|
+                    begin
+                        case k
+                        when :filters
+                            v.each{|f|o = f.filter(o)}
+                        when :procs
+                            v.each{|pr|o = pr.call(o)}
+                        end
+                    rescue ArgumentError
+                        # ignore this
+                    end
+                end
+            end
+            o
+        end
+
+        # Remove all filters
+        def clear
+            @filters.clear
+        end
+    end
+end

data/lib/pipeliner/Pipeline.rb

@@ -0,0 +1,154 @@
+['thread', 'splib', 'actionpool', 'pipeliner/FilterManager'].each{|f| require f}
+
+Splib.load :Constants
+
+module Pipeliner
+    class Pipeline
+        # args:: Hash containing initializations
+        #   :pool =>:: ActionPool::Pool for the Pipeline to use
+        #   :filters =>:: FilterManager for the Pipeline to use
+        # Create a new Pipeline
+        def initialize(args={})
+            @pool = args[:pool] ? args[:pool] : ActionPool::Pool.new
+            @hooks = {}
+            @lock = Mutex.new
+            @filters = args[:filters] ? args[:filters] : FilterManager.new
+        end
+
+        # Close the pipeline
+        # Note: This is important to at the end of a script when not
+        #       providing an ActionPool thread pool to the pipeline.
+        #       This will ensure the thread pool is properly shutdown
+        #       and avoid the script hanging.
+        def close
+            @pool.shutdown
+            clear
+            @pool = nil
+        end
+
+        # Open the pipeline
+        def open
+            @pool = ActionPool::Pool.new unless @pool
+        end
+        
+        # Returns current FilterManager
+        def filters
+            @filters
+        end
+
+        # fm:: FilterManager
+        # Set the FilterManager the Pipeline should use
+        def filters=(fm)
+            raise ArgumentError.new('Expecting a FilterManager') unless fm.is_a?(FilterManager)
+            @filters = fm
+        end
+
+        # type:: Type of Objects to pass to object
+        # object:: Object to hook to pipeline
+        # method:: Method to call on object
+        # block:: Block to apply to object (called without object and method set)
+        # Hooks an Object into the pipeline for objects of a given type
+        def hook(type, object=nil, method=nil, &block)
+            raise ArgumentError.new('No object information or block provided for hook') if !block_given? && object.nil? && method.nil?
+            raise ArgumentError.new('Block must accept a parameter') unless block.nil? || block.arity == 1 || block.arity < 0
+            @lock.synchronize do
+                const = Splib.find_const(type)
+                type = const unless const.nil?
+                @hooks[type] ||= {}
+                if(block_given?)
+                    @hooks[type][:procs] ||= []
+                    @hooks[type][:procs] << block
+                end
+                if(object && method)
+                    name = object.class
+                    method = method.to_sym
+                    raise ArgumentError.new('Given object does not respond to given method') unless object.respond_to?(method)
+                    @hooks[type][name] ||= []
+                    @hooks[type][name] << {:object => object, :method => method}
+                end
+            end
+            block_given? ? block : nil
+        end
+
+        # object:: Object or Proc to unhook from the pipeline
+        # type:: Type of Objects being received
+        # method:: method registered to call
+        # Remove a hook from the pipeline. If the method and type are not
+        # specified, the given object will be removed from all hooks
+        def unhook(object, type=nil, method=nil)
+            raise ArgumentError.new('Object method provided for a Proc') if object.is_a?(Proc) && method
+            @lock.synchronize do
+                case object
+                when Proc
+                    if(type)
+                        @hooks[type][:procs].delete(object)
+                        @hooks[type].delete(:procs) if @hooks[type][:procs].empty?
+                    else
+                        @hooks.each_value do |h|
+                            h[:procs].delete(object)
+                            h.delete(:procs) if h[:procs].empty?
+                        end
+                    end
+                else
+                    if(method.nil? && type.nil?)
+                        @hooks.each_value{|v|v.delete_if{|k,z| k == object.class}}
+                    else
+                        raise ArgumentError.new('Type must be provided') if type.nil?
+                        const = Splib.find_const(type)
+                        type = const unless const.nil?
+                        method = method.to_sym if method
+                        name = object.class
+                        raise NameError.new('Uninitialized hook type given') unless @hooks[type]
+                        raise StandardError.new('No hooks found for given object') unless @hooks[type][name]
+                        if(method)
+                            @hooks[type][name].delete_if{|x|x[:method] == method}
+                            @hooks[type].delete(name) if @hooks[type][name].empty?
+                        else
+                            @hooks[type].delete(name)
+                        end
+                    end                    
+                end
+                @hooks.delete_if{|k,v|v.empty?}
+            end
+        end
+
+        # Return current hooks hash
+        def hooks
+            @lock.synchronize{ @hooks.dup }
+        end
+
+        # Remove all hooks from the pipeline
+        def clear
+            @lock.synchronize{ @hooks.clear }
+        end
+
+        # object:: Object to send down the pipeline
+        # Send an object down the pipeline
+        def <<(object)
+            raise StandardError.new('Pipeline is currently closed') if @pool.nil?
+            object = @filters.apply_filters(object)
+            if(object)
+                object.freeze
+                @pool.process{ flush(object) }
+            end
+        end
+
+        private
+
+        # o:: Object to flush
+        # Applies object to all matching hooks
+        def flush(o)
+            @hooks.keys.each do |type|
+                next unless Splib.type_of?(o, type)
+                @hooks[type].each_pair do |key, objects|
+                    if(key == :procs)
+                        objects.each{|pr| @pool.process{ pr.call(o) }}
+                    else
+                        objects.each{|h| @pool.process{ h[:object].send(h[:method], o)}}
+                    end
+                end
+            end
+            nil
+        end
+    end
+end

data/lib/pipeliner.rb

@@ -0,0 +1 @@
+require 'pipeliner/Pipeline'

data/pipeliner.gemspec

@@ -0,0 +1,17 @@
+spec = Gem::Specification.new do |s|
+    s.name              = 'pipeliner'
+    s.author            = 'spox'
+    s.email             = 'spox@modspox.com'
+    s.version           = '1.0'
+    s.summary           = 'Object Pipeline'
+    s.platform          = Gem::Platform::RUBY
+    s.files             = Dir['**/*']
+    s.rdoc_options      = %w(--title pipeliner --main README.rdoc --line-numbers)
+    s.extra_rdoc_files  = %w(README.rdoc CHANGELOG)
+    s.require_paths     = %w(lib)
+    s.required_ruby_version = '>= 1.8.6'
+    s.add_dependency 'ActionPool', '~> 0.2.0'
+    s.add_dependency 'splib', '~> 1.1'
+    s.homepage          = %q(http://github.com/spox/pipeliner)
+    s.description       = "Simple library to allow pipeline styled communications between objects"
+end

data/tests/cases/Filter.rb

@@ -0,0 +1,29 @@
+require 'pipeliner'
+require 'test/unit'
+
+class FilterTest < Test::Unit::TestCase
+    def setup
+    end
+    def teardown
+    end
+
+    class MyFilter < Pipeliner::Filter
+        def do_filter(o)
+            return [o.to_sym]
+        end
+    end
+    
+    def test_basic
+        assert_raise(ArgumentError){ Pipeliner::Filter.new }
+        a = Pipeliner::Filter.new(String)
+        assert_kind_of(Pipeliner::Filter, a)
+        assert_raise(ArgumentError){ a.filter([1,2]) }
+        assert_raise(NoMethodError){ a.filter('test') }
+    end
+
+    def test_custom
+        a = MyFilter.new(String)
+        assert_kind_of(Array, a.filter('test'))
+        assert_equal([:test], a.filter('test'))
+    end
+end

data/tests/cases/FilterManager.rb

@@ -0,0 +1,75 @@
+require 'pipeliner'
+require 'test/unit'
+
+class FilterManagerTest < Test::Unit::TestCase
+    class MyFilter < Pipeliner::Filter
+        def do_filter(o)
+            "#{o}: filtered"
+        end
+    end
+    def setup
+        @fm = Pipeliner::FilterManager.new
+        @filter = MyFilter.new(String)
+    end
+    def teardown
+        @fm.clear
+    end
+
+    def test_add
+        @fm.add(String, @filter)
+        assert_equal(1, @fm.filters[String][:filters].size)
+        @fm.add(String, @filter)
+        assert_equal(1, @fm.filters[String][:filters].size)
+        @fm.add(String){|s|s}
+        assert_equal(1, @fm.filters[String][:procs].size)
+        assert_raise(ArgumentError) do
+            @fm.add(String, "string")
+        end
+        assert_raise(ArgumentError) do
+            @fm.add(Object)
+        end
+        @fm.clear
+        assert(@fm.filters.empty?)
+        @fm.add(String, @filter){|s|s}
+        assert_equal(1, @fm.filters[String][:filters].size)
+        assert_equal(1, @fm.filters[String][:procs].size)
+    end
+
+    def test_remove
+        @fm.add(String, @filter)
+        assert_equal(1, @fm.filters[String][:filters].size)
+        @fm.remove(@filter, String)
+        assert(!@fm.filters.has_key?(String))
+        @fm.add(String, @filter)
+        assert_equal(1, @fm.filters[String][:filters].size)
+        @fm.remove(@filter)
+        assert(!@fm.filters.has_key?(String))
+        pr = @fm.add(String){|s|s}
+        assert_equal(1, @fm.filters[String][:procs].size)
+        @fm.remove(pr, String)
+        assert(!@fm.filters.has_key?(String))
+        pr = @fm.add(String){|s|s}
+        assert_equal(1, @fm.filters[String][:procs].size)
+        @fm.remove(pr)
+        assert(!@fm.filters.has_key?(String))
+    end
+
+    def test_apply
+        @fm.add(String, @filter)
+        assert_equal("test: filtered", @fm.apply_filters("test"))
+        assert_equal(1, @fm.apply_filters(1))
+        data = "fubar"
+        assert_not_same(data, @fm.apply_filters(data))
+        data = [:fubar]
+        assert_same(data, @fm.apply_filters(data))
+        @fm.add(Fixnum){|o| "string"}
+        assert_kind_of(String, @fm.apply_filters(2))
+    end
+
+    def test_clear
+        @fm.add(String, @filter)
+        assert_equal(1, @fm.filters[String][:filters].size)
+        @fm.clear
+        assert(@fm.filters.empty?)
+    end
+end

data/tests/cases/Pipeline.rb

@@ -0,0 +1,111 @@
+require 'pipeliner'
+require 'test/unit'
+
+class PipelineTest < Test::Unit::TestCase
+    class Tester
+        def initialize
+            @m = []
+        end
+        def method(s)
+            @m << s
+        end
+        def messages
+            @m
+        end
+    end
+    def setup
+        @pipeline = Pipeliner::Pipeline.new
+    end
+    def teardown
+        @pipeline.filters.clear
+        @pipeline.clear
+        @pipeline.close
+    end
+    def test_filters
+        assert_kind_of(Pipeliner::FilterManager, @pipeline.filters)
+    end
+    def test_set_filters
+        fm = Pipeliner::FilterManager.new
+        assert_not_same(fm, @pipeline.filters)
+        @pipeline.filters = fm
+        assert_same(fm, @pipeline.filters)
+    end
+    def test_hook_addition
+        assert_raise(ArgumentError){ @pipeline.hook(String) }
+        assert_raise(ArgumentError){ @pipeline.hook(String){ true } }
+        assert_raise(ArgumentError){ @pipeline.hook(String){|a,b| true} }
+        assert_kind_of(Proc, @pipeline.hook(String){|a| true })
+        assert_kind_of(Proc, @pipeline.hook(String){|a, *b| true })
+        assert_kind_of(Proc, @pipeline.hook(String){|*a| true })
+        assert_equal(1, @pipeline.hooks.size)
+        assert_equal(3, @pipeline.hooks[String][:procs].size)
+        @pipeline.clear
+        assert(@pipeline.hooks.empty?)
+        object = Tester.new
+        assert_nil(@pipeline.hook(String, object, :method))
+        assert_equal(1, @pipeline.hooks[String][object.class].size)
+    end
+    def test_hook_deletion
+        pr = @pipeline.hook(String){|a| true}
+        assert_kind_of(Proc, pr)
+        assert_equal(1, @pipeline.hooks[String][:procs].size)
+        @pipeline.unhook(pr, String)
+        assert(@pipeline.hooks.empty?)
+        object = Tester.new
+        @pipeline.hook(String, object, :method)
+        assert_equal(1, @pipeline.hooks[String].size)
+        @pipeline.unhook(object, String, :method)
+        assert(@pipeline.hooks.empty?)
+        @pipeline.hook(String, object, :method)
+        assert_equal(1, @pipeline.hooks[String].size)
+        @pipeline.unhook(object, String)
+        assert(@pipeline.hooks.empty?)
+        @pipeline.hook(String, object, :method)
+        assert_equal(1, @pipeline.hooks[String].size)
+        @pipeline.unhook(object)
+        assert(@pipeline.hooks.empty?)
+        @pipeline.hook(String, object, :method)
+        @pipeline.hook(Object){|a|true}
+        assert_equal(2, @pipeline.hooks.size)
+        @pipeline.clear
+        assert(@pipeline.hooks.empty?)
+    end
+    def test_flush
+        out = []
+        assert(out.empty?)
+        @pipeline.hook(String){|x|out << x}
+        assert_equal(1, @pipeline.hooks.size)
+        @pipeline << "Fubar"
+        sleep(0.01)
+        assert_equal(1, out.size)
+        assert_equal("Fubar", out.pop)
+        @pipeline << 100
+        sleep(0.01)
+        assert(out.empty?)
+        object = Tester.new
+        @pipeline.hook(String, object, :method)
+        @pipeline.hook(Fixnum, object, :method)
+        assert_equal(2, @pipeline.hooks[String].size)
+        assert_equal(2, @pipeline.hooks.size)
+        @pipeline << 'test'
+        sleep(0.01)
+        assert_equal(object.messages.pop, out.pop)
+        @pipeline << 1
+        sleep(0.01)
+        assert(out.empty?)
+        assert_equal(1, object.messages.pop)
+    end
+    def test_filters
+        out = []
+        @pipeline.filters.add(String){|s|10}
+        @pipeline.hook(Object){|s|out << s}
+        @pipeline << 'fubar'
+        assert(out.include?(10))
+        assert(!out.include?('fubar'))
+        @pipeline.filters.clear
+        out.clear
+        @pipeline.filters.add(String){|s|nil}
+        @pipeline << 'test'
+        assert(out.empty?)
+    end
+end

data/tests/run_tests.rb

@@ -0,0 +1,8 @@
+$LOAD_PATH.unshift(File.expand_path("#{__FILE__}/../../lib"))
+
+require 'test/unit'
+require 'pipeliner'
+
+Dir.new("#{File.dirname(__FILE__)}/cases").each{|f|
+    require "#{File.dirname(__FILE__)}/cases/#{f}" if f[-2..f.size] == 'rb'
+}

metadata

@@ -0,0 +1,90 @@
+--- !ruby/object:Gem::Specification 
+name: pipeliner
+version: !ruby/object:Gem::Version 
+  version: "1.0"
+platform: ruby
+authors: 
+- spox
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-12-30 00:00:00 -08:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: ActionPool
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 0.2.0
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: splib
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: "1.1"
+    version: 
+description: Simple library to allow pipeline styled communications between objects
+email: spox@modspox.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+- CHANGELOG
+files: 
+- tests/cases/Filter.rb
+- tests/cases/FilterManager.rb
+- tests/cases/Pipeline.rb
+- tests/run_tests.rb
+- lib/pipeliner/Filter.rb
+- lib/pipeliner/FilterManager.rb
+- lib/pipeliner/Pipeline.rb
+- lib/pipeliner.rb
+- CHANGELOG
+- LICENSE
+- README.rdoc
+- pipeliner.gemspec
+has_rdoc: true
+homepage: http://github.com/spox/pipeliner
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --title
+- pipeliner
+- --main
+- README.rdoc
+- --line-numbers
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: 1.8.6
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Object Pipeline
+test_files: []
+