sax-machine 0.0.16 → 0.2.0.rc1

data/lib/sax-machine/sax_handler.rb

@@ -1,67 +1,191 @@
 require "nokogiri"
+require "time"
 
 module SAXMachine
   class SAXHandler < Nokogiri::XML::SAX::Document
-    attr_reader :stack
+    NO_BUFFER = :no_buffer
 
-    def initialize(object)
-      @stack = [[object, nil, ""]]
-      @parsed_configs = {}
+    class StackNode < Struct.new(:object, :config, :buffer)
+      def initialize(object, config = nil, buffer = NO_BUFFER)
+        self.object = object
+        self.config = config
+        self.buffer = buffer
+      end
     end
 
-    def characters(string)
-      object, config, value = stack.last
-      value << string
+    def initialize(object, on_error = nil, on_warning = nil)
+      @stack = [ StackNode.new(object) ]
+      @parsed_configs = {}
+      @on_error = on_error
+      @on_warning = on_warning
     end
 
-    def cdata_block(string)
-      characters(string)
+    def characters(data)
+      node = stack.last
+
+      if node.buffer == NO_BUFFER
+        node.buffer = data.dup
+      else
+        node.buffer << data
+      end
     end
+    alias cdata_block characters
 
     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
+
+      name   = normalize_name(name)
+      node   = stack.last
+      object = node.object
+
+      sax_config = sax_config_for(object)
 
       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
+          object     = collection_config.data_class.new
+          sax_config = sax_config_for(object)
+
+          stack.push(StackNode.new(object, collection_config))
+
+          set_attributes_on(object, attrs)
         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, ""]
+          new_object =
+            case element_config.data_class.to_s
+            when 'Integer' then 0
+            when 'Float'   then 0.0
+            when 'Time'    then Time.at(0)
+            when ''        then object
+            else
+              element_config.data_class.new
+            end
+
+          stack.push(StackNode.new(new_object, element_config))
+
+          set_attributes_on(new_object, attrs)
         end
       end
     end
 
     def end_element(name)
-      (object, tag_config, _), (element, config, value) = stack[-2..-1]
-      return unless stack.size > 1 && config && config.name.to_s == name.to_s
+      name = normalize_name(name)
+
+      start_tag = stack[-2]
+      close_tag = stack[-1]
+
+      return unless start_tag && close_tag
+
+      object  = start_tag.object
+      element = close_tag.object
+      config  = close_tag.config
+      value   = close_tag.buffer
+
+      return unless config.name == name
 
       unless parsed_config?(object, config)
+        if (element_value_config = element_values_for(config))
+          element_value_config.each { |evc| element.send(evc.setter, value) }
+        end
+
         if config.respond_to?(:accessor)
+          subconfig = sax_config_for(element)
+
+          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 == ""
+          value =
+            case config.data_class.to_s
+            when 'String'  then value.to_s
+            when 'Integer' then value.to_i
+            when 'Float'   then value.to_f
+            # Assumes that time elements will be string-based and are not
+            # something else, e.g. seconds since epoch
+            when 'Time'    then Time.parse(value.to_s)
+            when ''        then value
+            else
+              element
+            end
+
+          object.send(config.setter, value) unless value == NO_BUFFER
+
           mark_as_parsed(object, config)
         end
+
+        # try to set the ancestor
+        if (sax_config = sax_config_for(element))
+          sax_config.ancestors.each do |ancestor|
+            element.send(ancestor.setter, object)
+          end
+        end
       end
+
       stack.pop
     end
 
+    private
+
     def mark_as_parsed(object, element_config)
-      @parsed_configs[[object.object_id, element_config.object_id]] = true unless element_config.collection?
+      unless element_config.collection?
+        @parsed_configs[[object.object_id, element_config.object_id]] = true
+      end
     end
 
     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
+
+
+    def sax_config_for(object)
+      if object.class.respond_to?(:sax_config)
+        object.class.sax_config
+      end
+    end
+
+    def element_values_for(config)
+      if config.data_class.respond_to?(:sax_config)
+        config.data_class.sax_config.element_values_for_element
+      end
+    end
+
+    def normalize_name(name)
+      name.gsub(/\-/, '_')
+    end
+
+    def set_attributes_on(object, attributes)
+      config = sax_config_for(object)
+
+      if config
+        config.attribute_configs_for_element(attributes).each do |ac|
+          object.send(ac.setter, ac.value_from_attrs(attributes))
+        end
+      end
+    end
+
+    def stack
+      @stack
+    end
   end
-end
+end

data/lib/sax-machine/version.rb

@@ -0,0 +1,3 @@
+module SAXMachine
+  VERSION = "0.2.0.rc1"
+end

data/lib/sax-machine.rb

@@ -1,11 +1,8 @@
-require "rubygems"
-
-$LOAD_PATH.unshift(File.expand_path(File.dirname(__FILE__))) unless $LOAD_PATH.include?(File.expand_path(File.dirname(__FILE__)))
-
+require "sax-machine/version"
 require "sax-machine/sax_document"
+require "sax-machine/sax_configure"
 require "sax-machine/sax_handler"
 require "sax-machine/sax_config"
 
 module SAXMachine
-  VERSION = "0.0.16"
 end

data/sax-machine.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/sax-machine/version', __FILE__)
+
+Gem::Specification.new do |s|
+  s.name    = 'sax-machine'
+  s.version = SAXMachine::VERSION
+
+  s.authors   = ["Paul Dix", "Julien Kirch", "Ezekiel Templin"]
+  s.date      = Date.today
+  s.email     = %q{paul@pauldix.net}
+  s.homepage  = %q{http://github.com/pauldix/sax-machine}
+
+  s.summary   = %q{Declarative SAX Parsing with Nokogiri}
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.require_paths = ["lib"]
+
+  s.platform = Gem::Platform::RUBY
+
+  s.add_dependency 'nokogiri', "~> 1.5.2"
+  s.add_development_dependency "rspec", "~> 2.10.0"
+end

data/spec/benchmarks/amazon.xml

@@ -0,0 +1,40 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ItemSearchResponse xmlns="http://webservices.amazon.com/AWSECommerceService/2005-10-05">
+    <OperationRequest>
+        <HTTPHeaders>
+            <Header Name="UserAgent">
+            </Header>
+        </HTTPHeaders>
+        <RequestId>16WRJBVEM155Q026KCV1</RequestId>
+        <Arguments>
+            <Argument Name="SearchIndex" Value="Books"></Argument>
+            <Argument Name="Service" Value="AWSECommerceService"></Argument>
+            <Argument Name="Title" Value="Ruby on Rails"></Argument>
+            <Argument Name="Operation" Value="ItemSearch"></Argument>
+            <Argument Name="AWSAccessKeyId" Value="dontbeaswoosh"></Argument>
+        </Arguments>
+        <RequestProcessingTime>0.064924955368042</RequestProcessingTime>
+    </OperationRequest>
+    <Items>
+        <Request>
+            <IsValid>True</IsValid>
+            <ItemSearchRequest>
+                <SearchIndex>Books</SearchIndex>
+                <Title>Ruby on Rails</Title>
+            </ItemSearchRequest>
+        </Request>
+        <TotalResults>22</TotalResults>
+        <TotalPages>3</TotalPages>
+        <Item>
+            <ASIN>0321480791</ASIN>
+        <DetailPageURL>http://www.amazon.com/gp/redirect.html%3FASIN=0321480791%26tag=ws%26lcode=xm2%26cID=2025%26ccmID=165953%26location=/o/ASIN/0321480791%253FSubscriptionId=dontbeaswoosh</DetailPageURL>
+            <ItemAttributes>
+                <Author>Michael Hartl</Author>
+                <Author>Aurelius Prochazka</Author>
+                <Manufacturer>Addison-Wesley Professional</Manufacturer>
+                <ProductGroup>Book</ProductGroup>
+                <Title>RailsSpace: Building a Social Networking Website with Ruby on Rails (Addison-Wesley Professional Ruby Series)</Title>
+            </ItemAttributes>
+        </Item>
+    </Items>
+</ItemSearchResponse>

data/spec/benchmarks/benchmark.rb

@@ -0,0 +1,158 @@
+require 'rubygems'
+require 'benchmark'
+require 'happymapper'
+require 'sax-machine'
+require 'rfeedparser'
+include Benchmark
+benchmark_iterations = 100
+
+module Feedzirra
+  class AtomEntry
+    include SAXMachine
+    element :title
+    element :name, :as => :author
+    element "feedburner:origLink", :as => :url
+    element :summary
+    element :content
+    element :published
+  end
+  
+  # Class for parsing Atom feeds
+  class Atom
+    include SAXMachine
+    element :title
+    element :link, :value => :href, :as => :url, :with => {:type => "text/html"}
+    element :link, :value => :href, :as => :feed_url, :with => {:type => "application/atom+xml"}
+    elements :entry, :as => :entries, :class => AtomEntry
+  end
+end
+feed_text = File.read("spec/sax-machine/atom.xml")
+
+benchmark do |t|
+  t.report("feedzirra") do
+    benchmark_iterations.times {
+      Feedzirra::Atom.new.parse(feed_text)
+    }
+  end
+  
+  t.report("rfeedparser") do
+    benchmark_iterations.times {
+      FeedParser.parse(feed_text)
+    }
+  end
+end
+
+# class AtomEntry
+#   include SAXMachine
+#   element :title
+#   element :name, :as => :author
+#   element :summary  
+# end
+# class Atom
+#   include SAXMachine
+#   element :title
+#   elements :entry, :as => :entries, :class => AtomEntry  
+# end
+# 
+# class Entry
+#   include HappyMapper
+#   element :title, String
+#   element :name, String
+#   element :summary, String
+# end
+# class Feed
+#   include HappyMapper
+#   element :title, String
+#   has_many :entry, Entry
+# end
+# feed_text = File.read("spec/sax-machine/atom.xml")
+# 
+# benchmark do |t|
+#   t.report("sax-machine") do
+#     benchmark_iterations.times {
+#       Atom.new.parse(feed_text)
+#     }
+#   end
+#   
+#   t.report("happymapper") do
+#     benchmark_iterations.times {
+#       Feed.parse(feed_text)
+#     }
+#   end
+# end
+
+# xml = File.read("spec/benchmarks/public_timeline.xml")
+# class Status
+#   include HappyMapper
+# 
+#   element :text, String
+#   element :source, String
+# end
+# 
+# class Statuses
+#   include SAXMachine
+#   
+#   elements :status, {:as => :statuses, :class => Class.new do
+#     include SAXMachine
+#     element :text
+#     element :source
+#   end}
+# end
+# 
+# benchmark do |t|
+#   t.report("happy mapper") do
+#     benchmark_iterations.times {
+#       Status.parse(xml)
+#     }
+#   end
+#   
+#   t.report("sax-machine") do
+#     benchmark_iterations.times {
+#       Statuses.parse(xml)
+#     }
+#   end
+# end
+
+# xml = File.read("spec/benchmarks/amazon.xml")
+# class HItem
+#   include HappyMapper
+# 
+#   tag 'Item' # if you put class in module you need tag
+#   element :asin, String, :tag => 'ASIN'
+#   element :detail_page_url, String, :tag => 'DetailPageURL'
+#   element :manufacturer, String, :tag => 'Manufacturer', :deep => true
+# end
+# class HItems
+#   include HappyMapper
+# 
+#   tag 'Items' # if you put class in module you need tag
+#   # element :total_results, Integer, :tag => 'TotalResults'
+#   # element :total_pages, Integer, :tag => 'TotalPages'
+#   has_many :items, Item
+# end
+# 
+# class Item
+#   include SAXMachine
+#   
+#   element :ASIN, :as => :asin
+#   element :DetailPageUrl, :as => :detail_page_url
+#   element :Manufacturer, :as => :manufacturer
+# end
+# class Items
+#   include SAXMachine
+#   elements :Item, :as => :items
+# end
+# 
+# benchmark do |t|
+#   t.report("sax-machine") do
+#     benchmark_iterations.times {
+#       Items.new.parse(xml)
+#     }
+#   end
+#   
+#   t.report("happymapper") do
+#     benchmark_iterations.times {
+#       HItems.parse(xml)
+#     }
+#   end
+# end