sax-machine 0.0.14 → 0.0.15

data/lib/sax-machine.rb

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

data/lib/sax-machine/sax_collection_config.rb

@@ -8,25 +8,37 @@ module SAXMachine
         @name   = name.to_s
         @class  = options[:class]
         @as     = options[:as].to_s
-      end
-      
-      def handler
-        SAXHandler.new(@class.new)
+        
+        if options.has_key?(:with)
+          # for faster comparisons later
+          @with = options[:with].to_a.flatten.collect {|o| o.to_s}
+        else
+          @with = nil
+        end
       end
       
       def accessor
         as
       end
       
+      def attrs_match?(attrs)
+        if @with
+          @with == (@with & attrs)
+        else
+          true
+        end
+      end
+
+      def data_class
+        @class || @name
+      end      
+      
     protected
       
       def as
         @as
       end
       
-      def class
-        @class || @name
-      end      
     end
     
   end

data/lib/sax-machine/sax_config.rb

@@ -3,38 +3,45 @@ require "sax-machine/sax_collection_config"
 
 module SAXMachine
   class SAXConfig
-    attr_reader :top_level_elements, :collection_elements
-
+    attr_accessor :top_level_elements, :collection_elements
+    
     def initialize
-      @top_level_elements  = []
-      @collection_elements = []
+      @top_level_elements  = {}
+      @collection_elements = {}
+    end
+    
+    def columns
+      @top_level_elements.map {|name, ecs| ecs }.flatten
+    end
+    
+    def initialize_copy(sax_config)
+      @top_level_elements = sax_config.top_level_elements.clone
+      @collection_elements = sax_config.collection_elements.clone
     end
 
     def add_top_level_element(name, options)
-      @top_level_elements << ElementConfig.new(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_collection_element(name, options)
-      @collection_elements << CollectionConfig.new(name, options)
+      @collection_elements[name.to_s] = [] unless @collection_elements[name.to_s]
+      @collection_elements[name.to_s] << CollectionConfig.new(name, options)
     end
 
-    def collection_config(name)
-      @collection_elements.detect { |ce| ce.name.to_s == name.to_s }
+    def collection_config(name, attrs)
+      ces = @collection_elements[name.to_s]
+      ces && ces.detect { |cc| cc.attrs_match?(attrs) }
     end
 
     def element_configs_for_attribute(name, attrs)
-      @top_level_elements.select do |element_config|
-        element_config.name == name &&
-        element_config.has_value_and_attrs_match?(attrs)
-      end
+      tes = @top_level_elements[name.to_s]
+      tes && tes.select { |ec| ec.has_value_and_attrs_match?(attrs) } || []
     end
 
     def element_config_for_tag(name, attrs)
-      @top_level_elements.detect do |element_config|
-        element_config.name == name &&
-        element_config.attrs_match?(attrs)
-      end
+      tes = @top_level_elements[name.to_s]
+      tes && tes.detect { |ec| ec.attrs_match?(attrs) }
     end
-
   end
 end

data/lib/sax-machine/sax_document.rb

@@ -31,7 +31,7 @@ module SAXMachine
     end
 
     def columns
-      sax_config.top_level_elements
+      sax_config.columns
     end
 
     def column(sym)

data/lib/sax-machine/sax_element_config.rb

@@ -2,7 +2,7 @@ module SAXMachine
   class SAXConfig
     
     class ElementConfig
-      attr_reader :name, :setter, :data_class
+      attr_reader :name, :setter, :data_class, :collection
       
       def initialize(name, options)
         @name = name.to_s

data/lib/sax-machine/sax_handler.rb

@@ -2,19 +2,16 @@ require "nokogiri"
 
 module SAXMachine
   class SAXHandler < Nokogiri::XML::SAX::Document
-    attr_reader :object
+    attr_reader :stack
 
     def initialize(object)
-      @object = object
+      @stack = [[object, nil, ""]]
       @parsed_configs = {}
     end
 
     def characters(string)
-      if parsing_collection?
-        @collection_handler.characters(string)
-      elsif @element_config
-        @value << string
-      end
+      object, config, value = stack.last
+      value << string
     end
 
     def cdata_block(string)
@@ -22,95 +19,48 @@ module SAXMachine
     end
 
     def start_element(name, attrs = [])
-      @name   = name
-      @attrs  = attrs
-
-      if parsing_collection?
-        @collection_handler.start_element(@name, @attrs)
-
-      elsif @collection_config = sax_config.collection_config(@name)
-        @collection_handler = @collection_config.handler
-        @collection_handler.start_element(@name, @attrs)
-
-      elsif (element_configs = sax_config.element_configs_for_attribute(@name, @attrs)).any?
-        parse_element_attributes(element_configs)
-        set_element_config_for_element_value
+      object, config, value = stack.last
+      sax_config = object.class.respond_to?(:sax_config) ? object.class.sax_config : nil
 
-      else
-        set_element_config_for_element_value
+      if sax_config
+        if collection_config = sax_config.collection_config(name, attrs)
+          stack.push [object = collection_config.data_class.new, collection_config, ""]
+          object, sax_config, is_collection = object, object.class.sax_config, true
+        end
+        sax_config.element_configs_for_attribute(name, attrs).each do |ec|
+          unless parsed_config?(object, ec)
+            object.send(ec.setter, ec.value_from_attrs(attrs))
+            mark_as_parsed(object, ec)
+          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, ""]
+        end
       end
     end
 
     def end_element(name)
-      if parsing_collection? && @collection_config.name == name
-        @object.send(@collection_config.accessor) << @collection_handler.object
-        reset_current_collection
-
-      elsif parsing_collection?
-        @collection_handler.end_element(name)
-
-      elsif characaters_captured? && !parsed_config?
-        mark_as_parsed
-        @object.send(@element_config.setter, @value)
-      end
-
-      reset_current_tag
-    end
-
-    def characaters_captured?
-      !@value.nil? && !@value.empty?
-    end
-
-    def parsing_collection?
-      !@collection_handler.nil?
-    end
-
-    def parse_collection_instance_attributes
-      instance = @collection_handler.object
-      @attrs.each_with_index do |attr_name,index|
-        instance.send("#{attr_name}=", @attrs[index + 1]) if index % 2 == 0 && instance.methods.include?("#{attr_name}=")
-      end
-    end
-
-    def parse_element_attributes(element_configs)
-      element_configs.each do |ec|
-        unless parsed_config?(ec)
-          @object.send(ec.setter, ec.value_from_attrs(@attrs))
-          mark_as_parsed(ec)
+      (object, tag_config, _), (element, config, value) = stack[-2..-1]
+      return unless stack.size > 1 && config && config.name.to_s == name.to_s
+
+      unless parsed_config?(object, config)
+        if config.respond_to?(:accessor)
+          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
       end
-      @element_config = nil
-    end
-
-    def set_element_config_for_element_value
-      @value = ""
-      @element_config = sax_config.element_config_for_tag(@name, @attrs)
-    end
-
-    def mark_as_parsed(element_config=nil)
-      element_config ||= @element_config
-      @parsed_configs[element_config] = true unless element_config.collection?
-    end
-
-    def parsed_config?(element_config=nil)
-      element_config ||= @element_config
-      @parsed_configs[element_config]
-    end
-
-    def reset_current_collection
-      @collection_handler = nil
-      @collection_config  = nil
+      stack.pop
     end
 
-    def reset_current_tag
-      @name   = nil
-      @attrs  = nil
-      @value  = nil
-      @element_config = nil
+    def mark_as_parsed(object, element_config)
+      @parsed_configs[[object.object_id, element_config.object_id]] = true unless element_config.collection?
     end
 
-    def sax_config
-      @object.class.sax_config
+    def parsed_config?(object, element_config)
+      @parsed_configs[[object.object_id, element_config.object_id]]
     end
   end
 end

data/spec/sax-machine/sax_document_spec.rb

@@ -15,7 +15,7 @@ describe "SAXMachine" do
         document.title = "Title"
         document.title.should == "Title"
       end
-      
+
       it "should allow introspection of the elements" do
         @klass.column_names.should =~ [:title]
       end
@@ -54,7 +54,7 @@ describe "SAXMachine" do
           @klass.required?(:date).should be_true
         end
       end
-      
+
       it "should not overwrite the accessor when the element is not present" do
         document = @klass.new
         document.title = "Title"
@@ -73,7 +73,7 @@ describe "SAXMachine" do
         document = @klass.parse("<title>My Title</title>")
         document.title.should == "My Title"
       end
-      
+
       it "should save cdata into an accessor" do
         document = @klass.parse("<title><![CDATA[A Title]]></title>")
         document.title.should == "A Title"
@@ -86,7 +86,8 @@ describe "SAXMachine" do
 
       it "should save the first element text when there are multiple of the same element" do
         document = @klass.parse("<xml><title>My Title</title><title>bar</title></xml>")
-        document.title.should == "My Title"    
+        document.title.should == "My Title"
+
       end
     end
 
@@ -126,7 +127,7 @@ describe "SAXMachine" do
           document.summary.should == "here is a description"
         end
       end
-      
+
       describe "using the :with option" do
         describe "and the :value option" do
           before :each do
@@ -135,17 +136,17 @@ describe "SAXMachine" do
               element :link, :value => :href, :with => {:foo => "bar"}
             end
           end
-          
+
           it "should save the value of a matching element" do
             document = @klass.parse("<link href='test' foo='bar'>asdf</link>")
             document.link.should == "test"
           end
-          
+
           it "should save the value of the first matching element" do
             document = @klass.parse("<xml><link href='first' foo='bar' /><link href='second' foo='bar' /></xml>")
             document.link.should == "first"
           end
-          
+
           describe "and the :as option" do
             before :each do
               @klass = Class.new do
@@ -154,15 +155,16 @@ describe "SAXMachine" do
                 element :link, :value => :href, :as => :second_url, :with => {:asdf => "jkl"}
               end
             end
-            
+
             it "should save the value of the first matching element" do
               document = @klass.parse("<xml><link href='first' foo='bar' /><link href='second' asdf='jkl' /><link href='second' foo='bar' /></xml>")
               document.url.should == "first"
               document.second_url.should == "second"
-            end            
+            end
+
           end
         end
-        
+
         describe "with only one element" do
           before :each do
             @klass = Class.new do
@@ -183,15 +185,16 @@ describe "SAXMachine" do
 
           it "should save the text of an element that has matching attributes when it is the second of that type" do
             document = @klass.parse("<xml><link>no match</link><link foo=\"bar\">match</link></xml>")
-            document.link.should == "match"          
+            document.link.should == "match"
+
           end
-          
+
           it "should save the text of an element that has matching attributes plus a few more" do
             document = @klass.parse("<xml><link>no match</link><link asdf='jkl' foo='bar'>match</link>")
             document.link.should == "match"
           end
         end
-        
+
         describe "with multiple elements of same tag" do
           before :each do
             @klass = Class.new do
@@ -200,19 +203,19 @@ describe "SAXMachine" do
               element :link, :as => :second, :with => {:asdf => "jkl"}
             end
           end
-          
+
           it "should match the first element" do
             document = @klass.parse("<xml><link>no match</link><link foo=\"bar\">first match</link><link>no match</link></xml>")
             document.first.should == "first match"
           end
-          
+
           it "should match the second element" do
             document = @klass.parse("<xml><link>no match</link><link foo='bar'>first match</link><link asdf='jkl'>second match</link><link>hi</link></xml>")
             document.second.should == "second match"
           end
         end
       end # using the 'with' option
-      
+
       describe "using the 'value' option" do
         before :each do
           @klass = Class.new do
@@ -220,22 +223,22 @@ describe "SAXMachine" do
             element :link, :value => :foo
           end
         end
-        
+
         it "should save the attribute value" do
           document = @klass.parse("<link foo='test'>hello</link>")
           document.link.should == 'test'
         end
-        
+
         it "should save the attribute value when there is no text enclosed by the tag" do
           document = @klass.parse("<link foo='test'></link>")
           document.link.should == 'test'
         end
-        
+
         it "should save the attribute value when the tag close is in the open" do
           document = @klass.parse("<link foo='test'/>")
           document.link.should == 'test'
         end
-        
+
         it "should save two different attribute values on a single tag" do
           @klass = Class.new do
             include SAXMachine
@@ -246,7 +249,7 @@ describe "SAXMachine" do
           document.first.should == "foo value"
           document.second.should == "bar value"
         end
-        
+
         it "should not fail if one of the attribute hasn't been defined" do
           @klass = Class.new do
             include SAXMachine
@@ -258,7 +261,7 @@ describe "SAXMachine" do
           document.second.should be_nil
         end
       end
-      
+
       describe "when desiring both the content and attributes of an element" do
         before :each do
           @klass = Class.new do
@@ -276,10 +279,10 @@ describe "SAXMachine" do
           document.link_bar.should == 'test2'
         end
       end
-      
+
     end
   end
-  
+
   describe "elements" do
     describe "when parsing multiple elements" do
       before :each do
@@ -288,23 +291,23 @@ describe "SAXMachine" do
           elements :entry, :as => :entries
         end
       end
-      
+
       it "should provide a collection accessor" do
         document = @klass.new
         document.entries << :foo
         document.entries.should == [:foo]
       end
-      
+
       it "should parse a single element" do
         document = @klass.parse("<entry>hello</entry>")
         document.entries.should == ["hello"]
       end
-      
+
       it "should parse multiple elements" do
         document = @klass.parse("<xml><entry>hello</entry><entry>world</entry></xml>")
         document.entries.should == ["hello", "world"]
       end
-      
+
       it "should parse multiple elements when taking an attribute value" do
         attribute_klass = Class.new do
           include SAXMachine
@@ -314,7 +317,40 @@ describe "SAXMachine" do
         doc.entries.should == ["asdf", "jkl"]
       end
     end
-    
+
+    describe "when using the with and class options" do
+      before :each do
+        class Bar
+          include SAXMachine
+          element :title
+        end
+
+        class Foo
+          include SAXMachine
+          element :title
+        end
+
+        class Item
+          include SAXMachine
+
+        end
+        @klass = Class.new do
+          include SAXMachine
+          elements :item, :as => :items, :with => {:type => 'Bar'}, :class => Bar
+          elements :item, :as => :items, :with => {:type => 'Foo'}, :class => Foo
+        end
+      end
+
+      it "should cast into the correct class" do
+        document = @klass.parse("<items><item type=\"Bar\"><title>Bar title</title></item><item type=\"Foo\"><title>Foo title</title></item></items>")
+        document.items.size.should == 2
+        document.items.first.should be_a(Bar)
+        document.items.first.title.should == "Bar title"
+        document.items.last.should be_a(Foo)
+        document.items.last.title.should == "Foo title"
+      end
+    end
+
     describe "when using the class option" do
       before :each do
         class Foo
@@ -326,26 +362,26 @@ describe "SAXMachine" do
           elements :entry, :as => :entries, :class => Foo
         end
       end
-      
+
       it "should parse a single element with children" do
         document = @klass.parse("<entry><title>a title</title></entry>")
         document.entries.size.should == 1
         document.entries.first.title.should == "a title"
       end
-      
+
       it "should parse multiple elements with children" do
         document = @klass.parse("<xml><entry><title>title 1</title></entry><entry><title>title 2</title></entry></xml>")
         document.entries.size.should == 2
         document.entries.first.title.should == "title 1"
         document.entries.last.title.should == "title 2"
       end
-      
+
       it "should not parse a top level element that is specified only in a child" do
         document = @klass.parse("<xml><title>no parse</title><entry><title>correct title</title></entry></xml>")
         document.entries.size.should == 1
         document.entries.first.title.should == "correct title"
       end
-      
+
       it "should parse out an attribute value from the tag that starts the collection" do
         class Foo
           element :entry, :value => :href, :as => :url
@@ -355,9 +391,10 @@ describe "SAXMachine" do
         document.entries.first.title.should == "paul"
         document.entries.first.url.should == "http://pauldix.net"
       end
-    end    
+    end
+
   end
-  
+
   describe "full example" do
     before :each do
       @xml = File.read('spec/sax-machine/atom.xml')
@@ -370,7 +407,7 @@ describe "SAXMachine" do
         element :content
         element :published
       end
-        
+
       class Atom
         include SAXMachine
         element :title
@@ -379,10 +416,112 @@ describe "SAXMachine" do
         elements :entry, :as => :entries, :class => AtomEntry
       end
     end # before
-    
+
     it "should parse the url" do
       f = Atom.parse(@xml)
       f.url.should == "http://www.pauldix.net/"
     end
   end
+
+  describe "parsing a tree" do
+    before do
+      @xml = %[
+      <categories>
+        <category id="1">
+          <title>First</title>
+          <categories>
+            <category id="2">
+              <title>Second</title>
+            </category>
+          </categories>
+        </category>
+      </categories>
+      ]
+      class CategoryCollection; end
+      class Category
+        include SAXMachine
+        attr_accessor :id
+        element :category, :value => :id, :as => :id
+        element :title
+        element :categories, :as => :collection, :class => CategoryCollection
+      end
+      class CategoryCollection
+        include SAXMachine
+        elements :category, :as => :categories, :class => Category
+      end
+      @collection = CategoryCollection.parse(@xml)
+    end
+
+    it "should parse the first category" do
+      @collection.categories.first.id.should == "1"
+      @collection.categories.first.title.should == "First"
+    end
+
+    it "should parse the nested category" do
+      @collection.categories.first.collection.categories.first.id.should == "2"
+      @collection.categories.first.collection.categories.first.title.should == "Second"
+    end
+  end
+
+  describe "parsing a tree without a collection class" do
+    before do
+      @xml = %[
+      <categories>
+        <category id="1">
+          <title>First</title>
+          <categories>
+            <category id="2">
+              <title>Second</title>
+            </category>
+          </categories>
+        </category>
+      </categories>
+      ]
+      class CategoryTree
+        include SAXMachine
+        attr_accessor :id
+        element :category, :value => :id, :as => :id
+        element :title
+        elements :category, :as => :categories, :class => CategoryTree
+      end
+      @collection = CategoryTree.parse(@xml)
+    end
+
+    it "should parse the first category" do
+      @collection.categories.first.id.should == "1"
+      @collection.categories.first.title.should == "First"
+    end
+
+    it "should parse the nested category" do
+      @collection.categories.first.categories.first.id.should == "2"
+      @collection.categories.first.categories.first.title.should == "Second"
+    end
+  end
+
+  describe "with element deeper inside the xml structure" do
+    before do
+      @xml = %[
+        <item id="1">
+          <texts>
+            <title>Hello</title>
+          </texts>
+        </item>
+      ]
+      @klass = Class.new do
+        include SAXMachine
+        attr_accessor :id
+        element :item, :value => "id", :as => :id
+        element :title
+      end
+      @item = @klass.parse(@xml)
+    end
+
+    it "should have an id" do
+      @item.id.should == "1"
+    end
+
+    it "should have a title" do
+      @item.title.should == "Hello"
+    end
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: sax-machine
 version: !ruby/object:Gem::Version 
-  version: 0.0.14
+  version: 0.0.15
 platform: ruby
 authors: 
 - Paul Dix