sax_stream 0.1.0

data/LICENSE

@@ -0,0 +1,21 @@
+== MIT License
+
+Copyright (c) 2012, Craig Ambrose
+
+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.markdown

@@ -0,0 +1,96 @@
+# Sax Stream
+
+[![Build Status](https://secure.travis-ci.org/craigambrose/sax_stream.png)](http://travis-ci.org/craigambrose/sax_stream)
+
+An XML parsing library using Nokogiri's Sax Parser which uses an object mapper to build objects from XML nodes and lets you use them as they are built, rather than waiting until the file is fully parsed.
+
+The two main goals of this process are:
+
+1. To avoid loading the entire XML file stream into memory at once.
+2. To avoid loading all the mapped objects into memory simultaneously.
+
+This is currently only for XML importing. Supporting exporting too would be nice if I need it.
+
+## Status
+
+Supports basic XML examples. Still needs to be tested with more complex XML.
+Even slightly invalid XML is likely to cause an immediate exception.
+
+## Installation
+
+Not yet packed as a gem, install it from github.
+
+## Usage
+
+### Define your mapper classes
+
+These are object definitions that you would like to extract from the XML. I recommend sticking with fairly thin classes for these. In the past, I've used similar libraries like ROXML and inherited my mapping classes from ActiveRecord or other base classes, and ended up with poorly designed code. Your mapper classes should do one thing only, provide access to structured in-memory data which can be streamed from XML.
+
+```ruby
+require 'sax_stream/mapper'
+
+class Product
+  include SaxStream::Mapper
+
+  node 'product'
+  map :id,             :to => '@id'
+  map :status,         :to => '@status'
+  map :name_confirmed, :to => 'name/@confirmed'
+  map :name,           :to => 'name'
+end
+```
+
+In this example, Product is a mapping class. It maps to an xml node named "product". Each "attribute" on this product object is defined using the "map" class method. The :to option uses a syntax which is similar to XPath, but not the same. Slashes seperate levels in the XML node heirarchy. If the data is in an attribute, this is designated by the @symbol. Obviously attributes must be at the end of the path, as they have no children. This product class is used to parse XML like this:
+
+```xml
+<?xml version="1.0" encoding="UTF-8"?>
+<product id="123" status="new">
+  <name confirmed="yes">iPhone 5G</name>
+</product>
+```
+
+All data written to your object from the XML will be string, unless you convert the. To specify a converter on a field mapping, use the :as option.
+
+```ruby
+  map :created_at, :to => '@createdAt', :as => DateTime
+```
+
+The :as option can be handed any object which supports a "parse" method, which takes a string as it's first and only parameter, and outputs the converted value. It looks particularly good if this converter is also a class, which indicates that the converted value will be an instance of this class.
+
+This library doesn't include any converters, so the DateTime example above wont work out of the box. However, if you are using the active_support gem, then Date, Time & DateTime will all work as values for :as. If you're dealing with a file format that formats dates (or some other object) in an unusual way, simply define your own.
+
+```ruby
+class UnusualDate
+  def self.parse(string)
+    # convert this unusual string to a Date
+    # No need to check for nil, sax_stream does that
+  end
+end
+```
+
+### Run the parser
+
+The parser object must be supplied with a collector and an array of mapping classes to use.
+
+```ruby
+require 'sax_stream/parser'
+
+collector = SaxStream::NaiveCollector.new
+parser = SaxStream::Parser.new(collector, [Product])
+
+parser.parse_stream(File.open('products.xml'))
+```
+
+The purpose of the collector is to be given the object once it has been built. It's basically any object which supports the "<<" operator (so yes, an Array works as a collector). SaxStream includes a NaiveCollector which you can use, but it's so named to remind you that this probably isn't what you want to do.
+
+If you use the example above, you will get some memory benefits over using a library like ROXML or HappyMapper, because the XML file is at least being processed as a stream, and not held in memory. This lets you process a very large file. However, the naive collector is holding all the created objects in memory, so as you parse the file, this gets bigger.
+
+To get the full benefits of this library, supply a collector which does something else with the objects as they are received, such as save them to a database.
+
+I plan to supply a batching collector which will collect a certain number of objects before passing them off to another collector you supply, so you can save objects in batches of 100 or whatever is optimal for your application.
+
+## Author
+
+Craig Ambrose
+
+http://www.craigambrose.com

data/lib/sax_stream/errors.rb

@@ -0,0 +1,7 @@
+module SaxStream
+  class ImportError < Exception; end
+
+  class ProgramError < ImportError; end
+  class UnexpectedNode < ImportError; end
+  class UnexpectedAttribute < ImportError; end
+end

data/lib/sax_stream/internal/child_mapping.rb

@@ -0,0 +1,65 @@
+require 'sax_stream/internal/mapper_handler'
+require 'sax_stream/internal/singular_relationship_collector'
+
+module SaxStream
+  module Internal
+    class ChildMapping
+      attr_reader :name
+
+      # Supported options are :to, :as & :parent_collects. See Mapper.relate documentation for more details.
+      def initialize(name, options)
+        @name = name.to_s
+        @parent_collects = options[:parent_collects]
+        process_conversion_type(options[:as])
+      end
+
+      def handler_for(node_path, collector, handler_stack, parent_object)
+        node_name = node_path.split('/').last
+        @mapper_classes.each do |mapper_class|
+          if mapper_class.maps_node?(node_name)
+            return MapperHandler.new(mapper_class, child_collector(parent_object, collector), handler_stack)
+          end
+        end
+        nil
+      end
+
+      def map_value_onto_object(object, value)
+      end
+
+      def build_empty_relation
+        [] if @plural
+      end
+
+      private
+
+        def child_collector(parent_object, collector)
+          if @parent_collects
+            if @plural
+              parent_object.relations[name]
+            else
+              SingularRelationshipCollector.new(parent_object, @name)
+            end
+          else
+            collector
+          end
+        end
+
+        def arrayify(value)
+          value.is_a?(Enumerable) ? value : [value]
+        end
+
+        def process_conversion_type(as)
+          @plural = as.is_a?(Enumerable)
+          @mapper_classes = arrayify(as).compact
+          if @mapper_classes.empty?
+            raise ":as options for #{@name} field is empty, for child nodes it must be a mapper class or array of mapper classes"
+          end
+          @mapper_classes.each do |mapper_class|
+            unless mapper_class.respond_to?(:map_key_onto_object)
+              raise ":as options for #{@name} field contains #{mapper_class.inspect} which does not appear to be a valid mapper class"
+            end
+          end
+        end
+    end
+  end
+end

data/lib/sax_stream/internal/combined_handler.rb

@@ -0,0 +1,27 @@
+require 'sax_stream/errors'
+
+module SaxStream
+  module Internal
+    class CombinedHandler
+      def initialize(stack, mapper_handlers)
+        @stack = stack
+        @handlers = mapper_handlers
+      end
+
+      def start_element(name, *other_params)
+        handler = handle_for_element_name(name)
+        raise UnexpectedNode, "Could not find a handler for the element start: #{name.inspect}" unless handler
+        @stack.push(handler)
+        handler.start_element(name, *other_params)
+      end
+
+      private
+
+        def handle_for_element_name(name)
+          @handlers.detect do |handler|
+            handler if handler.maps_node?(name)
+          end
+        end
+    end
+  end
+end

data/lib/sax_stream/internal/element_stack.rb

@@ -0,0 +1,81 @@
+require 'sax_stream/errors'
+
+module SaxStream
+  module Internal
+    class ElementStack
+      class Element
+        attr_accessor :name
+
+        def initialize(name, attrs)
+          @name = name
+          @attrs = attrs
+          @content = nil
+        end
+
+        def attributes(prefix = nil)
+          prefix ||= @name
+          @attrs.map do |key, value|
+            ["#{prefix}/@#{key}", value]
+          end
+        end
+
+        def content
+          @content
+        end
+
+        def record_characters(string)
+          @content ||= ''
+          @content += string
+        end
+      end
+
+      def initialize
+        @elements = []
+      end
+
+      def top_name
+        @elements.last.name if @elements.last
+      end
+
+      def push(name, attrs)
+        @elements.push(Element.new(name, attrs))
+        # indented_puts "push element #{name}"
+      end
+
+      def pop
+        raise ProgramError, "attempting to pop an empty ElementStack" if @elements.empty?
+        # indented_puts "pop element"
+        @elements.pop
+      end
+
+      def empty?
+        @elements.empty?
+      end
+
+      def path
+        @elements.map(&:name).join('/')
+      end
+
+      def content
+        @elements.last.content
+      end
+
+      def attributes
+        @elements.last.attributes(path)
+      end
+
+      def record_characters(string)
+        # indented_puts "  record: #{string.inspect}"
+        @elements.last.record_characters(string)
+      end
+
+      private
+
+        def indented_puts(string)
+          indent = ''
+          @elements.length.times { indent << '  ' }
+          puts indent + string
+        end
+    end
+  end
+end

data/lib/sax_stream/internal/field_mapping.rb

@@ -0,0 +1,33 @@
+module SaxStream
+  module Internal
+    class FieldMapping
+      def initialize(name, options = {})
+        @name = name.to_s
+        @path = options[:to]
+        process_conversion_type(options[:as])
+      end
+
+      def map_value_onto_object(object, value)
+        if value && @parser
+          value = @parser.parse(value)
+        end
+        object[@name] = value
+      end
+
+      def handler_for(name, collector, handler_stack, parent_object)
+      end
+
+      private
+
+        def process_conversion_type(as)
+          if as
+            if as.respond_to?(:parse)
+              @parser = as
+            else
+              raise ArgumentError, ":as options for #{@name} field is a #{as.inspect} which must respond to parse"
+            end
+          end
+        end
+    end
+  end
+end

data/lib/sax_stream/internal/handler_stack.rb

@@ -0,0 +1,27 @@
+module SaxStream
+  module Internal
+    class HandlerStack
+      def initialize()
+        @handlers = []
+      end
+
+      def root=(value)
+        @handlers = [value]
+      end
+
+      def top
+        @handlers.last
+      end
+
+      def push(handler)
+        @handlers.push(handler)
+      end
+
+      def pop(handler = nil)
+        raise ProgramError, "can't pop the last handler" if @handlers.length <= 1
+        raise ProgramError, "popping handler that isn't the top" if handler && handler != @handlers.last
+        @handlers.pop
+      end
+    end
+  end
+end

data/lib/sax_stream/internal/mapper_handler.rb

@@ -0,0 +1,115 @@
+require 'sax_stream/internal/element_stack'
+
+module SaxStream
+  module Internal
+    # Handles SAX events on behalf of a mapper class. Expects the first event to be start_element, and then
+    # uses other events to build the element until end_element is received, at which time the completed
+    # object will be sent off to the collector.
+    #
+    # Also handles child elements which use their own mapper class, and will pass off SAX control to other
+    # handlers to achieve this.
+    class MapperHandler
+      attr_accessor :stack
+      attr_reader :mapper_class, :collector
+
+      # mapper_class::  A class which has had SaxStream::Mapper included in it.
+      #
+      # collector::     The collector object used for this parsing run. This gets passed around to everything
+      #                 that needs it.
+      #
+      # handler_stack:: The current stack of Sax handling objects for this parsing run. This gets passed around
+      #                 to everything that needs it. This class does not need to push itself onto the stack,
+      #                 that has already been done for it. If it pushes other handlers onto the stack, then
+      #                 it will no longer be handling SAX events itself until they get popped off.
+      #
+      # element_stack:: Used internally by this object to collect XML elements that have been parsed which may
+      #                 be used when mapping this class. You don't need to pass this in except for dependency
+      #                 injection purposes.
+      def initialize(mapper_class, collector, handler_stack, element_stack = ElementStack.new)
+        raise ArgumentError, "no collector" unless collector
+        raise ArgumentError, "no mapper class" unless mapper_class
+        raise ArgumentError, "no handler stack" unless handler_stack
+        raise ArgumentError, "no element stack" unless element_stack
+
+        @mapper_class = mapper_class
+        @collector = collector
+        @element_stack = element_stack
+        @stack = handler_stack
+      end
+
+      def maps_node?(node_name)
+        @mapper_class.maps_node?(node_name)
+      end
+
+      def start_element(name, attrs = [])
+        start_current_object(name, attrs) || start_child_node(name, attrs) || start_child_data(name, attrs)
+      end
+
+      def end_element(name)
+        pop_element_stack(name) || end_current_object(name)
+      end
+
+      def cdata_block(string)
+        characters(string)
+      end
+
+      def characters(string)
+        unless @element_stack.empty?
+          @element_stack.record_characters(string)
+        end
+      end
+
+      def current_object
+        @current_object
+      end
+
+      private
+
+        def start_current_object(name, attrs)
+          if maps_node?(name)
+            @current_object = @mapper_class.new
+            attrs.each do |key, value|
+              @mapper_class.map_attribute_onto_object(@current_object, key, value)
+            end
+            @current_object
+          end
+        end
+
+        def start_child_node(name, attrs)
+          handler = @mapper_class.child_handler_for(prefix_with_element_stack(name), @collector, @stack, @current_object)
+          if handler
+            @stack.push(handler)
+            handler.start_element(name, attrs)
+            handler
+          end
+        end
+
+        def start_child_data(name, attrs)
+          raise ProgramError, "received child element #{name.inspect} before receiving main expected node #{@mapper_class.node_name.inspect}" unless current_object
+          @element_stack.push(name, attrs)
+        end
+
+        def pop_element_stack(name)
+          unless @element_stack.empty?
+            raise ProgramError "received end element event for #{name.inspect} but currently processing #{@element_stack.top_name.inspect}" unless @element_stack.top_name == name
+            @mapper_class.map_element_stack_top_onto_object(@current_object, @element_stack)
+            @element_stack.pop
+          end
+        end
+
+        def end_current_object(name)
+          raise ProgramError unless @current_object
+          raise ArgumentError, "received end element event for #{name.inspect} but currently processing #{@current_object.class.node_name.inspect}" unless @current_object.class.node_name == name
+          if @current_object.class.should_collect?
+            @collector << @current_object
+          end
+          @stack.pop(self)
+          @current_object = nil
+        end
+
+        def prefix_with_element_stack(name)
+          [@element_stack.path, name].reject {|part| part.nil? || part == ''}.join('/')
+        end
+    end
+  end
+end

data/lib/sax_stream/internal/sax_handler.rb

@@ -0,0 +1,26 @@
+require 'nokogiri'
+require 'sax_stream/internal/handler_stack'
+require 'sax_stream/internal/combined_handler'
+
+module SaxStream
+  module Internal
+    class SaxHandler < Nokogiri::XML::SAX::Document
+      def initialize(collector, mappers, handler_stack = HandlerStack.new)
+        @handler_stack = handler_stack
+        mapper_handlers = mappers.map do |mapper|
+          MapperHandler.new(mapper, collector, @handler_stack)
+        end
+        @handler_stack.root = CombinedHandler.new(@handler_stack, mapper_handlers)
+      end
+
+      [:start_element, :end_element, :characters, :cdata_block].each do |key|
+        code = <<-RUBY
+        def #{key}(*params)
+          @handler_stack.top.#{key}(*params)
+        end
+        RUBY
+        module_eval(code)
+      end
+    end
+  end
+end

data/lib/sax_stream/internal/singular_relationship_collector.rb

@@ -0,0 +1,17 @@
+module SaxStream
+  module Internal
+    class SingularRelationshipCollector
+      def initialize(parent, relation_name)
+        @parent = parent
+        @relation_name = relation_name
+      end
+
+      def <<(value)
+        if @parent.relations[@relation_name]
+          raise ProgramError, "found singular relationship #{@relation_name.inspect} occuring more than once. Existing is #{@parent.relations[@relation_name].inspect}"
+        end
+        @parent.relations[@relation_name] = value
+      end
+    end
+  end
+end

data/lib/sax_stream/mapper.rb

@@ -0,0 +1,162 @@
+require 'sax_stream/internal/field_mapping'
+require 'sax_stream/internal/child_mapping'
+
+module SaxStream
+  # Include this module to make your class map an XML node. For usage examples, see the READEME.
+  module Mapper
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+      def node(name, options = {})
+        @node_name = name
+        @collect = options.has_key?(:collect) ? options[:collect] : true
+      end
+
+      def map(attribute_name, options = {})
+        store_field_mapping(options[:to], Internal::FieldMapping.new(attribute_name, options))
+      end
+
+      # Define a relation to another object which is built from an XML node using another class
+      # which also includes SaxStream::Mapper.
+      #
+      # attribute_name:: The name of the attribute on your object that the related objects will be stored in.
+      # options::        An options hash which can accept the following-
+      #                    [:to] Default value: "*"
+      #                          The path to the XML which defines an instance of this related node. This
+      #                          is a bit like an XPath expression, but not quite. See the README for examples.
+      #                          For relations, this can include a wildcard "*" as the last part of the path,
+      #                          eg: "product/review/*". If the path is just set to "*" then this will match
+      #                          any immediate child of the current node, which is good for polymorphic collections.
+      #                    [:as] Required, no default value.
+      #                          Needs to be a class which includes SaxStream::Mapper, or an array of such classes.
+      #                          Using an array of classes, even if the array only has one item, denotes that an
+      #                          array of related items are expected. Calling @object.relations['name'] will return
+      #                          an array which will be empty if nothing is found. If a singular value is used for
+      #                          the :as option, then the relation will be assumed to be singular, and so it will
+      #                          be nil or the expected class (and will raise an error if multiples are in the file).
+      #                    [:parent_collects] Default value: false
+      #                          Set to true if the object defining this relationship (ie, the parent
+      #                          in the relationship) needs to collect the defined children. If so, the
+      #                          parent object will be used as the collector for these children, and they
+      #                          will not be passed to the collector supplied to the parser. Use this when
+      #                          the child objects are not something you want to process on their own, but
+      #                          instead you want them all to be loaded into the parent which will then be
+      #                          collected as normal. If this is left false, then the parent ojbect will
+      #                          not be informed of it's children, because they will be passed to the collector
+      #                          and then forgotten about. However, the children will know about their parent,
+      #                          or at least what is known about it, but the parent will not be finished being
+      #                          parsed. The parent will have already parsed all XML attributes though.
+      def relate(attribute_name, options = {})
+        store_relation_mapping(options[:to] || '*', Internal::ChildMapping.new(attribute_name, options))
+      end
+
+      def node_name
+        @node_name
+      end
+
+      def maps_node?(name)
+        @node_name == name
+      end
+
+      def map_attribute_onto_object(object, key, value)
+        map_key_onto_object(object, "@#{key}", value)
+      end
+
+      def map_element_stack_top_onto_object(object, element_stack)
+        map_key_onto_object(object, element_stack.path, element_stack.content)
+        element_stack.attributes.each do |key, value|
+          map_key_onto_object(object, key, value)
+        end
+      end
+
+      def map_key_onto_object(object, key, value)
+        mapping = field_mapping(key)
+        if mapping
+          mapping.map_value_onto_object(object, value)
+        end
+      end
+
+      def child_handler_for(key, collector, handler_stack, current_object)
+        mapping = field_mapping(key)
+        if mapping
+          mapping.handler_for(key, collector, handler_stack, current_object)
+        end
+      end
+
+      def relation_mappings
+        @relation_mappings ||= []
+      end
+
+      def should_collect?
+        @collect
+      end
+
+      private
+
+        def store_relation_mapping(key, mapping)
+          relation_mappings << mapping
+          store_field_mapping(key, mapping)
+        end
+
+        def store_field_mapping(key, mapping)
+          if key.include?('*')
+            regex_mappings << [Regexp.new(key.gsub('*', '[^/]+')), mapping]
+          else
+            mappings[key] = mapping
+          end
+        end
+
+        def field_mapping(key)
+          mappings[key] || regex_field_mapping(key)
+        end
+
+        def regex_field_mapping(key)
+          regex_mappings.each do |regex, mapping|
+            return mapping if regex =~ key
+          end
+          nil
+        end
+
+        def regex_mappings
+          @regex_mappings ||= []
+        end
+
+        def mappings
+          @mappings ||= {}
+        end
+    end
+
+    def []=(key, value)
+      attributes[key] = value
+    end
+
+    def [](key)
+      attributes[key]
+    end
+
+    def inspect
+      "#{self.class.name}: #{attributes.inspect}"
+    end
+
+    def attributes
+      @attributes ||= {}
+    end
+
+    def relations
+      @relations ||= build_empty_relations
+    end
+
+    private
+
+      def build_empty_relations
+        result = {}
+        self.class.relation_mappings.each do |relation_mapping|
+          result[relation_mapping.name] = relation_mapping.build_empty_relation
+        end
+        result
+      end
+
+  end
+end

data/lib/sax_stream/naive_collector.rb

@@ -0,0 +1,19 @@
+module SaxStream
+  class NaiveCollector
+    def initialize
+      @objects = []
+    end
+
+    def mapped_objects
+      @objects
+    end
+
+    def <<(value)
+      @objects << value
+    end
+
+    def for_type(klass)
+      mapped_objects.select { |object| object.class == klass }
+    end
+  end
+end

data/lib/sax_stream/parser.rb

@@ -0,0 +1,18 @@
+require 'sax_stream/errors'
+require 'sax_stream/internal/mapper_handler'
+require 'sax_stream/internal/sax_handler'
+
+module SaxStream
+  class Parser
+    def initialize(collector, mappers)
+      raise ArgumentError, "You must supply your parser with a collector" unless collector
+      raise ArgumentError, "You must supply your parser with at least one mapper class" if mappers.empty?
+      @sax_handler = Internal::SaxHandler.new(collector, mappers)
+    end
+
+    def parse_stream(io_stream)
+      parser = Nokogiri::XML::SAX::Parser.new(@sax_handler)
+      parser.parse(io_stream)
+    end
+  end
+end

metadata

@@ -0,0 +1,71 @@
+--- !ruby/object:Gem::Specification
+name: sax_stream
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Craig Ambrose
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-04-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: &70166827474840 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.4.0
+  type: :runtime
+  prerelease: false
+  version_requirements: *70166827474840
+description: 
+email:
+- craig@craigambrose.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/sax_stream/errors.rb
+- lib/sax_stream/internal/child_mapping.rb
+- lib/sax_stream/internal/combined_handler.rb
+- lib/sax_stream/internal/element_stack.rb
+- lib/sax_stream/internal/field_mapping.rb
+- lib/sax_stream/internal/handler_stack.rb
+- lib/sax_stream/internal/mapper_handler.rb
+- lib/sax_stream/internal/sax_handler.rb
+- lib/sax_stream/internal/singular_relationship_collector.rb
+- lib/sax_stream/mapper.rb
+- lib/sax_stream/naive_collector.rb
+- lib/sax_stream/parser.rb
+- LICENSE
+- README.markdown
+homepage: http://github.com/craigambrose/sax_stream
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.6
+signing_key: 
+specification_version: 3
+summary: A streaming XML parser which builds objects and passes them to a collecter
+  as they are ready
+test_files: []