sax-machine 0.0.15 → 0.0.20

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+gem 'nokogiri', '>= 1.4.4'
+gem 'rspec', '>= 2.6.0'

data/README.textile

@@ -23,6 +23,7 @@ class AtomEntry
   element :summary
   element :content
   element :published
+  parent :parent
 end
 
 # Class for parsing Atom feeds
@@ -43,10 +44,11 @@ feed = Atom.parse(xml_text)
 feed.title # => whatever the title of the blog is
 feed.url # => the main url of the blog
 feed.feed_url # => goes to the feedburner feed
- 
+
 feed.entries.first.title # => title of the first entry
 feed.entries.first.author # => the author of the first entry
 feed.entries.first.url # => the permalink on the blog for this entry
+feed.entries.first.parent # => the Atom parent
 # etc ...
 
 # you can also use the elements method without specifying a class like so
@@ -62,11 +64,11 @@ response.messages.last  # => "world"
 h2. LICENSE
 
 (The MIT License)
- 
-Copyright (c) 2009:
- 
+
+Copyright (c) 2009 - 2011:
+
 "Paul Dix":http://pauldix.net
- 
+
 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
@@ -74,10 +76,10 @@ 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.

data/Rakefile

@@ -1,14 +1,21 @@
-require "spec"
-require "spec/rake/spectask"
-require 'lib/sax-machine.rb'
+require "rspec/core/rake_task"
 
-Spec::Rake::SpecTask.new do |t|
-  t.spec_opts = ['--options', "\"#{File.dirname(__FILE__)}/spec/spec.opts\""]
-  t.spec_files = FileList['spec/**/*_spec.rb']
+$LOAD_PATH.unshift File.expand_path('../lib', __FILE__)
+require 'sax-machine'
+
+desc "Run all specs"
+RSpec::Core::RakeTask.new do |t|
+  t.rspec_opts = ['--options', "\"#{File.dirname(__FILE__)}/spec/spec.opts\""]
+end
+
+task :default => [:spec]
+
+task :test do
+    sh 'rspec spec'
 end
 
 task :install do
   rm_rf "*.gem"
   puts `gem build sax-machine.gemspec`
   puts `sudo gem install sax-machine-#{SAXMachine::VERSION}.gem`
-end
+end

data/lib/sax-machine/sax_attribute_config.rb

@@ -0,0 +1,40 @@
+module SAXMachine
+  class SAXConfig
+
+    class AttributeConfig
+      attr_reader :name, :setter
+
+      def initialize(name, options)
+        @name = name.to_s
+        @as = options[:as]
+        @setter = "#{@as}="
+        @required = options[:required]
+      end
+
+      def column
+        @as || @name.to_sym
+      end
+
+      def required?
+        @required
+      end
+
+      def value_from_attrs(attrs)
+        attrs.index(@name) ? attrs[attrs.index(@name) + 1] : nil
+      end
+
+      def attrs_match?(attrs)
+        attrs.index(@name) ? true : false
+      end
+
+      def has_value_and_attrs_match?(attrs)
+        attrs_match?(attrs)
+      end
+
+      def collection?
+        false
+      end
+    end
+
+  end
+end

data/lib/sax-machine/sax_config.rb

@@ -1,47 +1,74 @@
+require "sax-machine/sax_attribute_config"
+require "sax-machine/sax_element_value_config"
 require "sax-machine/sax_element_config"
 require "sax-machine/sax_collection_config"
+require "sax-machine/sax_parent_config"
 
 module SAXMachine
   class SAXConfig
-    attr_accessor :top_level_elements, :collection_elements
-    
+
+    attr_accessor :top_level_elements, :top_level_attributes, :top_level_element_value, :collection_elements, :parents
+
     def initialize
-      @top_level_elements  = {}
-      @collection_elements = {}
+      # Default value is an empty array
+      @top_level_elements  = Hash.new { |hash, key| hash[key] = [] }
+      @top_level_attributes  = []
+      @top_level_element_value = []
+      @collection_elements = Hash.new { |hash, key| hash[key] = [] }
+      @parents = []
     end
-    
+
     def columns
       @top_level_elements.map {|name, ecs| ecs }.flatten
     end
-    
+
     def initialize_copy(sax_config)
+      super
       @top_level_elements = sax_config.top_level_elements.clone
+      @top_level_attributes = sax_config.top_level_attributes.clone
+      @top_level_element_value = sax_config.top_level_element_value.clone
       @collection_elements = sax_config.collection_elements.clone
+      @parents = sax_config.parents.clone
     end
 
     def add_top_level_element(name, options)
-      @top_level_elements[name.to_s] = [] unless @top_level_elements[name.to_s]
       @top_level_elements[name.to_s] << ElementConfig.new(name, options)
     end
 
+    def add_top_level_attribute(name, options)
+      @top_level_attributes << AttributeConfig.new(options.delete(:name), options)
+    end
+
+    def add_top_level_element_value(name, options)
+      @top_level_element_value << ElementValueConfig.new(options.delete(:name), options)
+    end
+
     def add_collection_element(name, options)
-      @collection_elements[name.to_s] = [] unless @collection_elements[name.to_s]
       @collection_elements[name.to_s] << CollectionConfig.new(name, options)
     end
 
+    def add_parent(name, options)
+      @parents << ParentConfig.new(name, options)
+    end
+
     def collection_config(name, attrs)
-      ces = @collection_elements[name.to_s]
-      ces && ces.detect { |cc| cc.attrs_match?(attrs) }
+      @collection_elements[name.to_s].detect { |cc| cc.attrs_match?(attrs) }
+    end
+
+    def attribute_configs_for_element(attrs)
+      @top_level_attributes.select { |aa| aa.attrs_match?(attrs) }
+    end
+
+    def element_values_for_element
+      @top_level_element_value
     end
 
     def element_configs_for_attribute(name, attrs)
-      tes = @top_level_elements[name.to_s]
-      tes && tes.select { |ec| ec.has_value_and_attrs_match?(attrs) } || []
+      @top_level_elements[name.to_s].select { |ec| ec.has_value_and_attrs_match?(attrs) }
     end
 
     def element_config_for_tag(name, attrs)
-      tes = @top_level_elements[name.to_s]
-      tes && tes.detect { |ec| ec.attrs_match?(attrs) }
+      @top_level_elements[name.to_s].detect { |ec| ec.attrs_match?(attrs) }
     end
   end
 end

data/lib/sax-machine/sax_document.rb

@@ -1,33 +1,50 @@
 require "nokogiri"
 
 module SAXMachine
-  
+
   def self.included(base)
     base.extend ClassMethods
   end
-  
-  def parse(xml_text)
-    sax_handler = SAXHandler.new(self)
+
+  def parse(xml_text, on_error = nil, on_warning = nil)
+    sax_handler = SAXHandler.new(self, on_error, on_warning)
     parser = Nokogiri::XML::SAX::Parser.new(sax_handler)
     parser.parse(xml_text)
     self
   end
-  
+
   module ClassMethods
 
-    def parse(xml_text)
-      new.parse(xml_text)
+    def inherited(subclass)
+      subclass.sax_config.send(:initialize_copy, self.sax_config)
     end
-    
+
+    def parse(xml_text, on_error = nil, on_warning = nil)
+      new.parse(xml_text, on_error, on_warning)
+    end
+
     def element(name, options = {})
-      options[:as] ||= name
+      real_name = (options[:as] ||= name).to_s
       sax_config.add_top_level_element(name, options)
-      
-      # we only want to insert the getter and setter if they haven't defined it from elsewhere.
-      # this is how we allow custom parsing behavior. So you could define the setter
-      # and have it parse the string into a date or whatever.
-      attr_reader options[:as] unless instance_methods.include?(options[:as].to_s)
-      attr_writer options[:as] unless instance_methods.include?("#{options[:as]}=")
+      create_attr real_name
+    end
+
+    def attribute(name, options = {})
+      real_name = (options[:as] ||= name).to_s
+      sax_config.add_top_level_attribute(self.class.to_s, options.merge(:name => name))
+      create_attr real_name
+    end
+
+    def value(name, options = {})
+      real_name = (options[:as] ||= name).to_s
+      sax_config.add_top_level_element_value(self.class.to_s, options.merge(:name => name))
+      create_attr real_name
+    end
+
+    def parent(name, options = {})
+      real_name = (options[:as] ||= name).to_s
+      sax_config.add_parent(name, options)
+      create_attr(real_name)
     end
 
     def columns
@@ -35,7 +52,7 @@ module SAXMachine
     end
 
     def column(sym)
-      columns.select{|c| c.column == sym}[0]
+      columns.select { |c| c.column == sym }[0]
     end
 
     def data_class(sym)
@@ -47,9 +64,9 @@ module SAXMachine
     end
 
     def column_names
-      columns.map{|e| e.column}
+      columns.map { |e| e.column }
     end
-    
+
     def elements(name, options = {})
       options[:as] ||= name
       if options[:class]
@@ -62,21 +79,29 @@ module SAXMachine
         SRC
         sax_config.add_top_level_element(name, options.merge(:collection => true))
       end
-      
-      if !instance_methods.include?(options[:as].to_s)
-      class_eval <<-SRC
+
+      if !method_defined?(options[:as].to_s)
+        class_eval <<-SRC
           def #{options[:as]}
             @#{options[:as]} ||= []
           end
         SRC
       end
-      
-      attr_writer options[:as] unless instance_methods.include?("#{options[:as]}=")
+
+      attr_writer options[:as] unless method_defined?("#{options[:as]}=")
     end
-    
+
     def sax_config
       @sax_config ||= SAXConfig.new
     end
+
+    # we only want to insert the getter and setter if they haven't defined it from elsewhere.
+    # this is how we allow custom parsing behavior. So you could define the setter
+    # and have it parse the string into a date or whatever.
+    def create_attr real_name
+      attr_reader real_name unless method_defined?(real_name)
+      attr_writer real_name unless method_defined?("#{real_name}=")
+    end
   end
-  
-end
+
+end

data/lib/sax-machine/sax_element_config.rb

@@ -31,6 +31,14 @@ module SAXMachine
         @data_class = options[:class]
         @required = options[:required]
       end
+      
+      def value_configured?
+        !@value.nil?
+      end
+
+      def to_s
+        "name: #{@name} dataclass: #{@data_class} setter: #{@setter} required: #{@required} value: #{@value} as:#{@as} collection: #{@collection} with: #{@with}"
+      end
 
       def column
         @as || @name.to_sym
@@ -62,4 +70,4 @@ module SAXMachine
     end
     
   end
-end
+end

data/lib/sax-machine/sax_element_value_config.rb

@@ -0,0 +1,24 @@
+module SAXMachine
+  class SAXConfig
+
+    class ElementValueConfig
+      attr_reader :name, :setter
+
+      def initialize(name, options)
+        @name = name.to_s
+        @as = options[:as]
+        @setter = "#{@as}="
+        @required = options[:required]
+      end
+
+      def column
+        @as || @name.to_sym
+      end
+
+      def required?
+        @required
+      end
+    end
+
+  end
+end

data/lib/sax-machine/sax_handler.rb

@@ -4,9 +4,11 @@ module SAXMachine
   class SAXHandler < Nokogiri::XML::SAX::Document
     attr_reader :stack
 
-    def initialize(object)
-      @stack = [[object, nil, ""]]
+    def initialize(object, on_error = nil, on_warning = nil)
+      @stack = [[object, nil, String.new]]
       @parsed_configs = {}
+      @on_error = on_error
+      @on_warning = on_warning
     end
 
     def characters(string)
@@ -19,13 +21,18 @@ module SAXMachine
     end
 
     def start_element(name, attrs = [])
+      attrs.flatten!
       object, config, value = stack.last
       sax_config = object.class.respond_to?(:sax_config) ? object.class.sax_config : nil
 
       if sax_config
         if collection_config = sax_config.collection_config(name, attrs)
-          stack.push [object = collection_config.data_class.new, collection_config, ""]
+          stack.push [object = collection_config.data_class.new, collection_config, String.new]
           object, sax_config, is_collection = object, object.class.sax_config, true
+
+          if (attribute_config = object.class.respond_to?(:sax_config) && object.class.sax_config.attribute_configs_for_element(attrs))
+            attribute_config.each { |ac| object.send(ac.setter, ac.value_from_attrs(attrs)) }
+          end
         end
         sax_config.element_configs_for_attribute(name, attrs).each do |ec|
           unless parsed_config?(object, ec)
@@ -34,7 +41,12 @@ module SAXMachine
           end
         end
         if !collection_config && element_config = sax_config.element_config_for_tag(name, attrs)
-          stack.push [element_config.data_class ? element_config.data_class.new : object, element_config, ""]
+          new_object = element_config.data_class ? element_config.data_class.new : object
+          stack.push [new_object, element_config, String.new]
+
+          if (attribute_config = new_object.class.respond_to?(:sax_config) && new_object.class.sax_config.attribute_configs_for_element(attrs))
+            attribute_config.each { |ac| new_object.send(ac.setter, ac.value_from_attrs(attrs)) }
+          end
         end
       end
     end
@@ -44,13 +56,29 @@ module SAXMachine
       return unless stack.size > 1 && config && config.name.to_s == name.to_s
 
       unless parsed_config?(object, config)
+        if (element_value_config = config.data_class.respond_to?(:sax_config) && config.data_class.sax_config.element_values_for_element)
+          element_value_config.each { |evc| element.send(evc.setter, value) }
+        end
+
         if config.respond_to?(:accessor)
+          subconfig = element.class.sax_config if element.class.respond_to?(:sax_config)
+          if econf = subconfig.element_config_for_tag(name, [])
+            element.send(econf.setter, value) unless econf.value_configured?
+          end
           object.send(config.accessor) << element
         else
           value = config.data_class ? element : value
           object.send(config.setter, value) unless value == ""
           mark_as_parsed(object, config)
         end
+
+        # try to set the parent
+        sax_config = element.class.respond_to?(:sax_config) ? element.class.sax_config : nil
+        if sax_config
+          sax_config.parents.each do |parent|
+            element.send(parent.setter, object)
+          end
+        end
       end
       stack.pop
     end
@@ -62,5 +90,18 @@ module SAXMachine
     def parsed_config?(object, element_config)
       @parsed_configs[[object.object_id, element_config.object_id]]
     end
+
+    def warning string
+      if @on_warning
+        @on_warning.call(string)
+      end
+    end
+
+    def error string
+      if @on_error
+        @on_error.call(string)
+      end
+    end
+
   end
-end
+end

data/lib/sax-machine/sax_parent_config.rb

@@ -0,0 +1,21 @@
+module SAXMachine
+  class SAXConfig
+
+    class ParentConfig
+      attr_reader :name, :setter
+
+      def initialize(name, options)
+        @name = name.to_s
+
+        @as = options[:as]
+        @setter = "#{@as}="
+      end
+
+      def column
+        @as || @name.to_sym
+      end
+
+    end
+
+  end
+end

data/lib/sax-machine.rb

@@ -7,5 +7,5 @@ require "sax-machine/sax_handler"
 require "sax-machine/sax_config"
 
 module SAXMachine
-  VERSION = "0.0.15"
+  VERSION = "0.0.16"
 end

data/spec/sax-machine/sax_document_spec.rb

@@ -20,11 +20,26 @@ describe "SAXMachine" do
         @klass.column_names.should =~ [:title]
       end
 
+      it "should not overwrite the getter is there is already one present" do
+        @klass = Class.new do
+          def title
+            "#{@title} ***"
+          end
+
+          include SAXMachine
+          element :title
+        end
+        document = @klass.new
+        document.title = "Title"
+        document.title.should == "Title ***"
+      end
+
       it "should not overwrite the setter if there is already one present" do
         @klass = Class.new do
           def title=(val)
             @title = "#{val} **"
           end
+
           include SAXMachine
           element :title
         end
@@ -105,6 +120,36 @@ describe "SAXMachine" do
         document.name.should == "Paul"
         document.title.should == "My Title"
       end
+
+
+      it "should not overwrite the getter is there is already one present" do
+        @klass = Class.new do
+          def items
+            []
+          end
+
+          include SAXMachine
+          elements :items
+        end
+        document = @klass.new
+        document.items = [1, 2, 3, 4]
+        document.items.should == []
+      end
+
+      it "should not overwrite the setter if there is already one present" do
+        @klass = Class.new do
+          def items=(val)
+            @items = [1, *val]
+          end
+
+          include SAXMachine
+          elements :items
+        end
+        document = @klass.new
+        document.items = [2, 3]
+        document.items.should == [1, 2, 3]
+      end
+
     end
 
     describe "when using options for parsing elements" do
@@ -382,6 +427,23 @@ describe "SAXMachine" do
         document.entries.first.title.should == "correct title"
       end
 
+      it "should parse elements, and make attributes and inner text available" do
+        class Related
+          include SAXMachine
+          element 'related', :as=>:item
+          element 'related', :as=>:attr, :value=>'attr'
+        end
+        class Foo
+          elements 'related', :as=>'items', :class=>Related
+        end
+
+        doc = Foo.parse(%{<xml><collection><related attr='baz'>something</related><related>somethingelse</related></collection></xml>})
+        doc.items.first.should_not be_nil
+        doc.items.size.should == 2
+        doc.items.first.item.should == 'something'
+        doc.items.last.item.should == 'somethingelse'
+      end
+
       it "should parse out an attribute value from the tag that starts the collection" do
         class Foo
           element :entry, :value => :href, :as => :url
@@ -392,7 +454,6 @@ describe "SAXMachine" do
         document.entries.first.url.should == "http://pauldix.net"
       end
     end
-
   end
 
   describe "full example" do
@@ -437,13 +498,15 @@ describe "SAXMachine" do
         </category>
       </categories>
       ]
-      class CategoryCollection; end
+      class CategoryCollection;
+      end
       class Category
         include SAXMachine
         attr_accessor :id
         element :category, :value => :id, :as => :id
         element :title
         element :categories, :as => :collection, :class => CategoryCollection
+        parent :parent
       end
       class CategoryCollection
         include SAXMachine
@@ -455,6 +518,7 @@ describe "SAXMachine" do
     it "should parse the first category" do
       @collection.categories.first.id.should == "1"
       @collection.categories.first.title.should == "First"
+      @collection.categories.first.parent.should == @collection
     end
 
     it "should parse the nested category" do
@@ -524,4 +588,151 @@ describe "SAXMachine" do
       @item.title.should == "Hello"
     end
   end
+
+  describe "with config to pull multiple attributes" do
+    before do
+      @xml = %[
+        <item id="1">
+          <author name="John Doe" role="writer" />
+        </item>
+      ]
+      class AuthorElement
+        include SAXMachine
+        attribute :name
+        attribute :role
+      end
+      class ItemElement
+        include SAXMachine
+        element :author, :class => AuthorElement
+      end
+      @item = ItemElement.parse(@xml)
+    end
+
+    it 'should have the child element' do
+      @item.author.should_not be_nil
+    end
+
+    it 'should have the author name' do
+      @item.author.name.should == 'John Doe'
+    end
+
+    it 'should have the author role' do
+      @item.author.role.should == 'writer'
+    end
+  end
+
+  describe "with multiple elements and multiple attributes" do
+    before do
+      @xml = %[
+        <item id="1">
+          <author name="John Doe" role="writer" />
+          <author name="Jane Doe" role="artist" />
+        </item>
+      ]
+      class AuthorElement2
+        include SAXMachine
+        attribute :name
+        attribute :role
+      end
+      class ItemElement2
+        include SAXMachine
+        elements :author, :as => :authors, :class => AuthorElement2
+      end
+      @item = ItemElement2.parse(@xml)
+    end
+
+    it 'should have the child elements' do
+      @item.authors.should_not be_nil
+      @item.authors.count.should == 2
+    end
+
+    it 'should have the author names' do
+      @item.authors.first.name.should == 'John Doe'
+      @item.authors.last.name.should == 'Jane Doe'
+    end
+
+    it 'should have the author roles' do
+      @item.authors.first.role.should == 'writer'
+      @item.authors.last.role.should == 'artist'
+    end
+  end
+
+  describe "with mixed attributes and element values" do
+    before do
+      @xml = %[
+        <item id="1">
+          <author role="writer">John Doe</author>
+        </item>
+      ]
+      class AuthorElement3
+        include SAXMachine
+        value :name
+        attribute :role
+      end
+      class ItemElement3
+        include SAXMachine
+        element :author, :class => AuthorElement3
+      end
+      @item = ItemElement3.parse(@xml)
+    end
+
+    it 'should have the child elements' do
+      @item.author.should_not be_nil
+    end
+
+    it 'should have the author names' do
+      @item.author.name.should == 'John Doe'
+    end
+
+    it 'should have the author roles' do
+      @item.author.role.should == 'writer'
+    end
+  end
+
+  describe "with multiple mixed attributes and element values" do
+    before do
+      @xml = %[
+        <item id="1">
+          <title>sweet</title>
+          <author role="writer">John Doe</author>
+          <author role="artist">Jane Doe</author>
+        </item>
+      ]
+      class AuthorElement4
+        include SAXMachine
+        value :name
+        attribute :role
+      end
+      class ItemElement4
+        include SAXMachine
+        element :title
+        elements :author, :as => :authors, :class => AuthorElement4
+
+        def title=(blah)
+          #raise 'woo'
+          @title = blah
+        end
+      end
+      @item = ItemElement4.parse(@xml)
+    end
+
+    it 'should have the title' do
+      @item.title.should == 'sweet'
+    end
+
+    it 'should have the child elements' do
+      @item.authors.should_not be_nil
+      @item.authors.count.should == 2
+    end
+
+    it 'should have the author names' do
+      @item.authors.first.name.should == 'John Doe'
+      @item.authors.last.name.should == 'Jane Doe'
+    end
+
+    it 'should have the author roles' do
+      @item.authors.first.role.should == 'writer'
+      @item.authors.last.role.should == 'artist'
+    end
+  end
 end

data/spec/spec_helper.rb

@@ -1,13 +1,11 @@
-require "rubygems"
-require "spec"
+require 'date'
 
 # gem install redgreen for colored test output
-begin require "redgreen" unless ENV['TM_CURRENT_LINE']; rescue LoadError; end
+begin require "redgreen" unless ENV['TM_CURRENT_LINE']
+  rescue LoadError
+end
 
 path = File.expand_path(File.dirname(__FILE__) + "/../lib/")
 $LOAD_PATH.unshift(path) unless $LOAD_PATH.include?(path)
 
-require "lib/sax-machine"
-
-# Spec::Runner.configure do |config|
-# end
+require "sax-machine"

metadata

@@ -1,27 +1,39 @@
 --- !ruby/object:Gem::Specification 
 name: sax-machine
 version: !ruby/object:Gem::Version 
-  version: 0.0.15
+  hash: 55
+  prerelease: 
+  segments: 
+  - 0
+  - 0
+  - 20
+  version: 0.0.20
 platform: ruby
 authors: 
 - Paul Dix
+- Julien Kirch
 autorequire: 
 bindir: bin
 cert_chain: []
 
-date: 2009-01-13 00:00:00 -05:00
-default_executable: 
+date: 2011-07-20 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: nokogiri
-  type: :runtime
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
     requirements: 
     - - ">"
       - !ruby/object:Gem::Version 
+        hash: 31
+        segments: 
+        - 0
+        - 0
+        - 0
         version: 0.0.0
-    version: 
+  type: :runtime
+  version_requirements: *id001
 description: 
 email: paul@pauldix.net
 executables: []
@@ -32,17 +44,19 @@ extra_rdoc_files: []
 
 files: 
 - lib/sax-machine.rb
+- lib/sax-machine/sax_attribute_config.rb
 - lib/sax-machine/sax_config.rb
+- lib/sax-machine/sax_document.rb
 - lib/sax-machine/sax_collection_config.rb
 - lib/sax-machine/sax_element_config.rb
-- lib/sax-machine/sax_document.rb
+- lib/sax-machine/sax_element_value_config.rb
 - lib/sax-machine/sax_handler.rb
+- lib/sax-machine/sax_parent_config.rb
 - README.textile
 - Rakefile
-- spec/spec.opts
+- Gemfile
 - spec/spec_helper.rb
 - spec/sax-machine/sax_document_spec.rb
-has_rdoc: true
 homepage: http://github.com/pauldix/sax-machine
 licenses: []
 
@@ -52,21 +66,27 @@ rdoc_options: []
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
       version: "0"
-  version: 
 required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
       version: "0"
-  version: 
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.5
+rubygems_version: 1.8.5
 signing_key: 
 specification_version: 2
 summary: Declarative SAX Parsing with Nokogiri

data/spec/spec.opts

@@ -1,2 +0,0 @@
---diff
---color