sax-machine-patched 0.2.0.rc2

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,12 @@
+language: ruby
+rvm:
+  - 1.9.2
+  - 1.9.3
+  - 2.0.0
+  - ruby-head
+  - jruby-19mode
+  - jruby-head
+  - rbx-19mode
+matrix:
+  allow_failures:
+    - rvm: ruby-head

data/Gemfile

@@ -0,0 +1,9 @@
+source "http://rubygems.org"
+
+gemspec
+
+group :development, :test do
+  gem 'rake'
+  gem 'guard-rspec'
+  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.md

@@ -0,0 +1,107 @@
+# SAX Machine [![Build Status](https://secure.travis-ci.org/pauldix/sax-machine.png?branch=master)](http://travis-ci.org/pauldix/sax-machine)
+
+[Wiki](https://github.com/pauldix/sax-machine/wiki)
+
+## Description
+
+A declarative SAX parsing library backed by Nokogiri
+
+## 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
+  element :title
+  # the :as argument makes this available through atom_entry.author instead of .name
+  element :name, :as => :author
+  element "feedburner:origLink", :as => :url
+  element :summary
+  element :content, :class => AtomContent
+  element :published
+  ancestor :ancestor
+end
+
+# Class for parsing Atom feeds
+class Atom
+  include SAXMachine
+  element :title
+  # the :with argument means that you only match a link tag that has an attribute of :type => "text/html"
+  # the :value argument means that instead of setting the value to the text between the tag,
+  # it sets it to the attribute value of :href
+  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
+
+# you can then parse like this
+feed = Atom.parse(xml_text)
+# then you're ready to rock
+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.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"
+
+# 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
+
+Copyright (c) 2009-2012:
+
+* [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
+'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/Rakefile

@@ -0,0 +1,6 @@
+#!/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.rb

@@ -0,0 +1,8 @@
+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
+end

data/lib/sax-machine/sax_ancestor_config.rb

@@ -0,0 +1,21 @@
+module SAXMachine
+  class SAXConfig
+
+    class AncestorConfig
+      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/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.fetch(@name, nil)
+      end
+
+      def attrs_match?(attrs)
+        attrs.key?(@name) || attrs.value?(@name)
+      end
+
+      def has_value_and_attrs_match?(attrs)
+        attrs_match?(attrs)
+      end
+
+      def collection?
+        false
+      end
+    end
+
+  end
+end

data/lib/sax-machine/sax_collection_config.rb

@@ -0,0 +1,37 @@
+module SAXMachine
+  class SAXConfig
+    
+    class CollectionConfig
+      attr_reader :name
+      
+      def initialize(name, options)
+        @name  = name.to_s
+        @class = options[:class]
+        @as    = options[:as].to_s
+        @with  = options.fetch(:with, {})
+      end
+      
+      def accessor
+        as
+      end
+      
+      def attrs_match?(attrs)
+        @with.all? do |key, value|
+          value === attrs[key.to_s]
+        end
+      end
+
+      def data_class
+        @class || @name
+      end      
+      
+    protected
+      
+      def as
+        @as
+      end
+      
+    end
+    
+  end
+end

data/lib/sax-machine/sax_config.rb

@@ -0,0 +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_ancestor_config"
+
+module SAXMachine
+  class SAXConfig
+
+    attr_accessor :top_level_elements, :top_level_attributes, :top_level_element_value, :collection_elements, :ancestors
+
+    def initialize
+      # 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] = [] }
+      @ancestors = []
+    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
+      @ancestors = sax_config.ancestors.clone
+    end
+
+    def add_top_level_element(name, options)
+      @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] << CollectionConfig.new(name, options)
+    end
+
+    def add_ancestor(name, options)
+      @ancestors << AncestorConfig.new(name, options)
+    end
+
+    def collection_config(name, 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)
+      @top_level_elements[name.to_s].select { |ec| ec.has_value_and_attrs_match?(attrs) }
+    end
+
+    def element_config_for_tag(name, attrs)
+      @top_level_elements[name.to_s].detect { |ec| ec.attrs_match?(attrs) }
+    end
+  end
+end

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

@@ -0,0 +1,118 @@
+require "nokogiri"
+
+module SAXMachine
+
+  def self.included(base)
+    base.send(:include, InstanceMethods)
+    base.extend ClassMethods
+  end
+
+  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) do |ctx|
+      ctx.replace_entities = true
+    end
+    self
+  end
+
+  module InstanceMethods
+    def initialize(attributes = {})
+      attributes.each do |name, value|
+        send("#{name}=", value)
+      end
+    end
+  end
+
+  module ClassMethods
+
+    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 = {})
+      real_name = (options[:as] ||= name).to_s
+      sax_config.add_top_level_element(name, options)
+      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 ancestor(name, options = {})
+      real_name = (options[:as] ||= name).to_s
+      sax_config.add_ancestor(name, options)
+      create_attr(real_name)
+    end
+
+    def columns
+      sax_config.columns
+    end
+
+    def column(sym)
+      columns.select { |c| c.column == sym }[0]
+    end
+
+    def data_class(sym)
+      column(sym).data_class
+    end
+
+    def required?(sym)
+      column(sym).required?
+    end
+
+    def column_names
+      columns.map { |e| e.column }
+    end
+
+    def elements(name, options = {})
+      options[:as] ||= name
+      if options[:class]
+        sax_config.add_collection_element(name, options)
+      else
+        class_eval <<-SRC
+          def add_#{options[:as]}(value)
+            #{options[:as]} << value
+          end
+        SRC
+        sax_config.add_top_level_element(name, options.merge(:collection => true))
+      end
+
+      if !method_defined?(options[:as].to_s)
+        class_eval <<-SRC
+          def #{options[:as]}
+            @#{options[:as]} ||= []
+          end
+        SRC
+      end
+
+      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