sax-machine 0.0.20 → 0.2.0.rc1

data/.gitignore

@@ -0,0 +1,8 @@
+.idea
+.bundle
+*.gem
+Gemfile.lock
+.rvmrc
+.DS_STORE
+pkg/
+coverage/

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format progress

data/.travis.yml

@@ -0,0 +1,9 @@
+language: ruby
+rvm:
+  - 1.8.7
+  - 1.9.2
+  - 1.9.3
+  - rbx-18mode
+  - rbx-19mode
+notifications:
+  irc: "irc.freenode.org#sax-machine"

data/Gemfile

@@ -1,4 +1,10 @@
 source "http://rubygems.org"
 
-gem 'nokogiri', '>= 1.4.4'
-gem 'rspec', '>= 2.6.0'
+gemspec
+
+group :development, :test do
+  gem 'rake'
+  gem 'guard-rspec'
+  gem 'growl', :require => false
+  gem 'simplecov', :require => false, :platforms => :mri_19
+end

data/Guardfile

@@ -0,0 +1,5 @@
+guard 'rspec', :version => 2 do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')  { "spec" }
+end

data/HISTORY.md

@@ -0,0 +1,13 @@
+# 0.2.0.rc1
+* Tried to reduce the number of instances of respond_to? in the code by
+  pulling common uses of it out to methods. [[#32](https://github.com/pauldix/sax-machine/pull/32)]
+* The parse stack is now composed of simple objects instead of it being
+  an array of arrays. [[#32](https://github.com/pauldix/sax-machine/pull/32)]
+* Now using an identifier for an empty buffer instead of empty string. [[#32](https://github.com/pauldix/sax-machine/pull/32)]
+* Cleaned up several variables that were not being used. [[#32](https://github.com/pauldix/sax-machine/pull/32)]
+* Encapsulated stack so it's not being exposed as part of the API. [[#32](https://github.com/pauldix/sax-machine/pull/32)]
+* #cdata_block is now an alias instead of delegating to characters. [[#32](https://github.com/pauldix/sax-machine/pull/32)]
+
+# 0.1.0
+* rename parent to ancestor
+* added SAXMachine.configure

data/{README.textile → README.md}

@@ -1,18 +1,24 @@
-h1. SAX Machine
+# SAX Machine [![Build Status](https://secure.travis-ci.org/pauldix/sax-machine.png?branch=master)](http://travis-ci.org/pauldix/sax-machine)
 
-"http://github.com/pauldix/sax-machine/wikis":http://github.com/pauldix/sax-machine/wikis
+[Wiki](https://github.com/pauldix/sax-machine/wiki)
 
-"http://github.com/pauldix/sax-machine/tree/master":http://github.com/pauldix/sax-machine/tree/master
-
-h2. Description
+## Description
 
 A declarative SAX parsing library backed by Nokogiri
 
-h2. Usage
-
-<pre>
+## Usage
+```ruby
 require 'sax-machine'
 
+# Class for information associated with content parts in a feed.
+#  Ex: <content type="text">sample</content>
+#  instance.type will be "text", instance.text will be "sample"
+class AtomContent
+  include SAXMachine
+  attribute :type
+  value :text
+end
+
 # Class for parsing an atom entry out of a feedburner atom feed
 class AtomEntry
   include SAXMachine
@@ -21,9 +27,9 @@ class AtomEntry
   element :name, :as => :author
   element "feedburner:origLink", :as => :url
   element :summary
-  element :content
+  element :content, :class => AtomContent
   element :published
-  parent :parent
+  ancestor :ancestor
 end
 
 # Class for parsing Atom feeds
@@ -48,26 +54,38 @@ 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
+feed.entries.first.ancestor # => the Atom ancestor
 # etc ...
 
 # you can also use the elements method without specifying a class like so
 class SomeServiceResponse
+  include SAXMachine
   elements :message, :as => :messages
 end
 
 response = SomeServiceResponse.parse("<response><message>hi</message><message>world</message></response>")
 response.messages.first # => "hi"
 response.messages.last  # => "world"
-</pre>
 
-h2. LICENSE
+# To limit conflicts in the class used for mappping, you can use the alternate SAXMachine.configure syntax
+
+class X < ActiveRecord::Base
+  # this way no element, elements or ancestor method will be added to X
+  SAXMachine.configure(X) do |c|
+    c.element :title
+  end
+end
+```
+
+## LICENSE
 
-(The MIT License)
+The MIT License
 
-Copyright (c) 2009 - 2011:
+Copyright (c) 2009-2012:
 
-"Paul Dix":http://pauldix.net
+* [Paul Dix](http://www.pauldix.net)
+* [Julien Kirch](http://www.archiloque.net)
+* [Ezekiel Templin](http://zeke.templ.in)
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/Rakefile

@@ -1,21 +1,6 @@
-require "rspec/core/rake_task"
-
-$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
+#!/usr/bin/env rake
+require "bundler/gem_tasks"
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec)
+task :test => :spec
+task :default => :test

data/lib/sax-machine/{sax_parent_config.rb → sax_ancestor_config.rb}

@@ -1,7 +1,7 @@
 module SAXMachine
   class SAXConfig
 
-    class ParentConfig
+    class AncestorConfig
       attr_reader :name, :setter
 
       def initialize(name, options)

data/lib/sax-machine/sax_config.rb

@@ -2,12 +2,12 @@ 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"
+require "sax-machine/sax_ancestor_config"
 
 module SAXMachine
   class SAXConfig
 
-    attr_accessor :top_level_elements, :top_level_attributes, :top_level_element_value, :collection_elements, :parents
+    attr_accessor :top_level_elements, :top_level_attributes, :top_level_element_value, :collection_elements, :ancestors
 
     def initialize
       # Default value is an empty array
@@ -15,7 +15,7 @@ module SAXMachine
       @top_level_attributes  = []
       @top_level_element_value = []
       @collection_elements = Hash.new { |hash, key| hash[key] = [] }
-      @parents = []
+      @ancestors = []
     end
 
     def columns
@@ -28,7 +28,7 @@ module SAXMachine
       @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
+      @ancestors = sax_config.ancestors.clone
     end
 
     def add_top_level_element(name, options)
@@ -47,8 +47,8 @@ module SAXMachine
       @collection_elements[name.to_s] << CollectionConfig.new(name, options)
     end
 
-    def add_parent(name, options)
-      @parents << ParentConfig.new(name, options)
+    def add_ancestor(name, options)
+      @ancestors << AncestorConfig.new(name, options)
     end
 
     def collection_config(name, attrs)

data/lib/sax-machine/sax_configure.rb

@@ -0,0 +1,38 @@
+module SAXMachine
+
+  def self.configure(clazz)
+    extended_clazz = Class.new(clazz)
+    extended_clazz.send(:include, SAXMachine)
+
+    # override create_attr to create attributes on the original class
+    def extended_clazz.create_attr real_name
+      superclass.send(:attr_reader, real_name) unless superclass.method_defined?(real_name)
+      superclass.send(:attr_writer, real_name) unless superclass.method_defined?("#{real_name}=")
+    end
+
+    yield(extended_clazz)
+
+    clazz.extend LightWeightSaxMachine
+    clazz.sax_config = extended_clazz.sax_config
+
+    (class << clazz;self;end).send(:define_method, :parse) do |xml_text|
+      extended_clazz.parse(xml_text)
+    end
+
+  end
+
+  module LightWeightSaxMachine
+
+    attr_writer :sax_config
+
+    def sax_config
+      @sax_config ||= SAXConfig.new
+    end
+
+    def inherited(subclass)
+      subclass.sax_config.send(:initialize_copy, self.sax_config)
+    end
+
+  end
+
+end

data/lib/sax-machine/sax_document.rb

@@ -41,9 +41,9 @@ module SAXMachine
       create_attr real_name
     end
 
-    def parent(name, options = {})
+    def ancestor(name, options = {})
       real_name = (options[:as] ||= name).to_s
-      sax_config.add_parent(name, options)
+      sax_config.add_ancestor(name, options)
       create_attr(real_name)
     end
 

data/lib/sax-machine/sax_handler.rb

@@ -1,107 +1,191 @@
 require "nokogiri"
+require "time"
 
 module SAXMachine
   class SAXHandler < Nokogiri::XML::SAX::Document
-    attr_reader :stack
+    NO_BUFFER = :no_buffer
+
+    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 initialize(object, on_error = nil, on_warning = nil)
-      @stack = [[object, nil, String.new]]
+      @stack = [ StackNode.new(object) ]
       @parsed_configs = {}
       @on_error = on_error
       @on_warning = on_warning
     end
 
-    def characters(string)
-      object, config, value = stack.last
-      value << string
-    end
+    def characters(data)
+      node = stack.last
 
-    def cdata_block(string)
-      characters(string)
+      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, String.new]
-          object, sax_config, is_collection = object, object.class.sax_config, true
+          object     = collection_config.data_class.new
+          sax_config = sax_config_for(object)
 
-          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
+          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)
-          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
+        if !collection_config && element_config = sax_config.element_config_for_tag(name, attrs)
+          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 = config.data_class.respond_to?(:sax_config) && config.data_class.sax_config.element_values_for_element)
+        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 = element.class.sax_config if element.class.respond_to?(:sax_config)
+          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 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)
+        # 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
+    def warning(string)
       if @on_warning
         @on_warning.call(string)
       end
     end
 
-    def error string
+    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

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>