sax-machine 0.0.16 → 0.2.0.rc1

data/.gitignore

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

data/.rspec

@@ -1,2 +1,2 @@
---require=./spec/spec_helper.rb
 --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.4.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,8 +27,9 @@ class AtomEntry
   element :name, :as => :author
   element "feedburner:origLink", :as => :url
   element :summary
-  element :content
+  element :content, :class => AtomContent
   element :published
+  ancestor :ancestor
 end
 
 # Class for parsing Atom feeds
@@ -43,30 +50,43 @@ 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.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
+
+Copyright (c) 2009-2012:
+
+* [Paul Dix](http://www.pauldix.net)
+* [Julien Kirch](http://www.archiloque.net)
+* [Ezekiel Templin](http://zeke.templ.in)
 
-(The MIT License)
- 
-Copyright (c) 2009:
- 
-"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 +94,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,19 +1,6 @@
-require "rspec/core/rake_task"
-require 'lib/sax-machine.rb'
-
-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_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.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_ancestor_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, :ancestors
+
     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] = [] }
+      @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] = [] 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_ancestor(name, options)
+      @ancestors << AncestorConfig.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_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

@@ -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 ancestor(name, options = {})
+      real_name = (options[:as] ||= name).to_s
+      sax_config.add_ancestor(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