sporkmonger-sax-machine 0.1.0

data/CHANGELOG

@@ -0,0 +1,3 @@
+== 0.1.0
+
+* forked from julien51/sax-machine

data/LICENSE

@@ -0,0 +1,20 @@
+SAX Machine, Copyright (c) 2009 Paul Dix
+
+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/README.md

@@ -0,0 +1,56 @@
+# SAX Machine
+
+A declarative sax parsing library backed by Nokogiri.
+
+# Example Usage
+
+    require 'sax-machine'
+
+    # 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
+      element :published
+    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
+    # etc ...
+
+    # you can also use the elements method without specifying a class like so
+    class SomeServiceResponse
+      elements :message, :as => :messages
+    end
+
+    response = SomeServiceResponse.parse("<response><message>hi</message><message>world</message></response>")
+    response.messages.first # => "hi"
+    response.messages.last  # => "world"
+
+# Install
+
+* sudo gem install sporkmonger-sax-machine

data/Rakefile

@@ -0,0 +1,53 @@
+lib_dir = File.expand_path(File.join(File.dirname(__FILE__), 'lib'))
+$:.unshift(lib_dir)
+$:.uniq!
+
+require 'rubygems'
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+require 'rake/packagetask'
+require 'rake/gempackagetask'
+
+begin
+  require 'spec/rake/spectask'
+rescue LoadError
+  STDERR.puts 'Please install rspec:'
+  STDERR.puts 'sudo gem install rspec'
+  exit(1)
+end
+
+require File.join(File.dirname(__FILE__), 'lib/sax-machine', 'version')
+
+PKG_DISPLAY_NAME   = 'SAX Machine'
+PKG_NAME           = 'sporkmonger-sax-machine'
+PKG_VERSION        = SAXMachine::VERSION::STRING
+PKG_FILE_NAME      = "#{PKG_NAME}-#{PKG_VERSION}"
+
+RELEASE_NAME       = "REL #{PKG_VERSION}"
+
+PKG_AUTHOR         = 'Paul Dix'
+PKG_AUTHOR_EMAIL   = 'paul@pauldix.net'
+PKG_HOMEPAGE       = 'https://github.com/sporkmonger/sax-machine'
+PKG_SUMMARY        = 'A declarative sax parsing library backed by Nokogiri.'
+PKG_DESCRIPTION    = <<-TEXT
+A declarative sax parsing library backed by Nokogiri.
+TEXT
+
+PKG_FILES = FileList[
+    'lib/**/*', 'spec/**/*', 'vendor/**/*',
+    'tasks/**/*', 'website/**/*',
+    '[A-Z]*', 'Rakefile'
+].exclude(/database\.yml/).exclude(/[_\.]git$/)
+
+RCOV_ENABLED = (RUBY_PLATFORM != 'java' && RUBY_VERSION =~ /^1\.8/)
+if RCOV_ENABLED
+  task :default => 'spec:verify'
+else
+  task :default => 'spec'
+end
+
+WINDOWS = (RUBY_PLATFORM =~ /mswin|win32|mingw|bccwin|cygwin/) rescue false
+SUDO = WINDOWS ? '' : ('sudo' unless ENV['SUDOLESS'])
+
+Dir['tasks/**/*.rake'].each { |rake| load rake }

data/lib/sax-machine.rb

@@ -0,0 +1,17 @@
+unless $LOAD_PATH.include?(File.expand_path(File.dirname(__FILE__)))
+  $LOAD_PATH.unshift(File.expand_path(File.dirname(__FILE__)))
+end
+
+require 'sax-machine/version'
+
+require 'cgi'
+
+require 'sax-machine/sax_document'
+require 'sax-machine/sax_handler'
+require 'sax-machine/sax_config'
+require 'sax-machine/sax_event_recorder'
+
+module SAXMachine
+  EMPTY_STRING = ''
+  COLON = ':'
+end

data/lib/sax-machine/ns_stack.rb

@@ -0,0 +1,41 @@
+module SAXMachine
+  class NSStack < Hash
+    XMLNS = 'xmlns'
+
+    def initialize(parent=nil, attrs=nil)
+      # Initialize
+      super()
+      @parent = parent
+
+      return self unless attrs
+      # Parse attributes
+      attrs.each do |attr|
+        if attr.kind_of?(Array)
+          k, v = attr
+          case k
+          when XMLNS then self[EMPTY_STRING] = v
+          when /^xmlns:(.+)/ then self[$1] = v
+          end
+        end
+      end
+    end
+
+    # Lookup
+    def [](name)
+      if (ns = super(name.to_s))
+        # I've got it
+        ns
+      elsif @parent
+        # Parent may have it
+        @parent[name]
+      else
+        # Undefined, empty namespace
+        EMPTY_STRING
+      end
+    end
+
+    def pop
+      @parent
+    end
+  end
+end

data/lib/sax-machine/sax_collection_config.rb

@@ -0,0 +1,56 @@
+module SAXMachine
+  class SAXConfig
+
+    class CollectionConfig
+      attr_reader :name
+      attr_reader :default_xmlns
+
+      def initialize(name, options)
+        @name   = name.to_s
+        @class  = options[:class]
+        @as     = options[:as].to_s
+        @xmlns  = case options[:xmlns]
+                  when Array then options[:xmlns]
+                  when String then [options[:xmlns]]
+                  else nil
+                  end
+        @default_xmlns = options[:default_xmlns]
+        if @default_xmlns && @xmlns && !@xmlns.include?(EMPTY_STRING)
+          @xmlns << EMPTY_STRING
+        end
+        @record_events = options[:events]
+      end
+
+      def handler(nsstack)
+        if @default_xmlns && (nsstack.nil? || nsstack[EMPTY_STRING] == EMPTY_STRING)
+          nsstack = NSStack.new(nsstack, nsstack)
+          nsstack[EMPTY_STRING] = @default_xmlns
+        end
+        unless @record_events
+          SAXHandler.new(@class.new, nsstack)
+        else
+          SAXEventRecorder.new(nsstack)
+        end
+      end
+
+      def accessor
+        as
+      end
+
+      def xmlns_match?(ns)
+        @xmlns.nil? || @xmlns.include?(ns)
+      end
+
+    protected
+
+      def as
+        @as
+      end
+
+      def class
+        @class || @name
+      end
+    end
+
+  end
+end

data/lib/sax-machine/sax_config.rb

@@ -0,0 +1,57 @@
+require 'sax-machine/sax_element_config'
+require 'sax-machine/sax_collection_config'
+
+module SAXMachine
+  class SAXConfig
+    attr_reader :top_level_elements, :collection_elements
+
+    def initialize
+      @top_level_elements  = {}
+      @collection_elements = {}
+    end
+
+    def add_top_level_element(name, options)
+      @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[name.to_s] ||= []
+      @collection_elements[name.to_s] << CollectionConfig.new(name, options)
+    end
+
+    def collection_config(name, nsstack)
+      prefix, name = name.split(COLON, 2)
+      prefix, name = nil, prefix unless name  # No prefix
+      namespace = nsstack[prefix]
+
+      return nil unless (a = @collection_elements[name.to_s])
+      a.detect { |ce|
+        ce.name.to_s == name.to_s &&
+        ce.xmlns_match?(namespace)
+      }
+    end
+
+    def element_configs_for_attribute(name, attrs)
+      name = name.split(COLON, 2).last
+
+      return [] unless (a = @top_level_elements[name.to_s])
+      a.select do |element_config|
+        element_config.has_value_and_attrs_match?(attrs)
+      end
+    end
+
+    def element_config_for_tag(name, attrs, nsstack)
+      prefix, name = name.split(COLON, 2)
+      prefix, name = nil, prefix unless name  # No prefix
+      namespace = nsstack[prefix]
+
+      return nil unless (a = @top_level_elements[name.to_s])
+      a.detect do |element_config|
+        element_config.xmlns_match?(namespace) &&
+        element_config.attrs_match?(attrs)
+      end
+    end
+
+  end
+end

data/lib/sax-machine/sax_document.rb

@@ -0,0 +1,107 @@
+require 'nokogiri'
+
+module SAXMachine
+
+  def self.included(base)
+    base.extend ClassMethods
+  end
+
+  def parse(xml_text)
+    unless @parser
+      sax_handler = SAXHandler.new(self)
+      @parser = Nokogiri::XML::SAX::PushParser.new(sax_handler)
+      @parser.options |= Nokogiri::XML::ParseOptions::RECOVER if @parser.respond_to?(:options)
+    end
+    @parser << xml_text
+    self
+  end
+
+  def parse_finish
+    if @parser
+      @parser.finish
+    end
+    self
+  end
+
+  module ClassMethods
+
+    def parse(xml_text)
+      # It might be cleaner to aditionally call parse_finish here, but
+      # then Nokogiri/libxml2 barfs on incomplete documents. Desired
+      # behaviour?
+      new.parse(xml_text)
+    end
+
+    def element(name, options = {})
+      options[:as] ||= name
+      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_once options[:as] unless instance_methods.include?("#{options[:as]}=")
+    end
+
+    def columns
+      r = []
+      sax_config.top_level_elements.each do |name, ecs|
+        r += ecs
+      end
+      r
+    end
+
+    def column(sym)
+      (sax_config.top_level_elements[sym.to_s] || []).first
+    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] || options[:events]
+        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 !instance_methods.include?(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]}=")
+    end
+
+    def sax_config
+      @sax_config ||= SAXConfig.new
+    end
+
+    def attr_writer_once(attr)
+      class_eval <<-SRC
+          def #{attr}=(val)
+            @#{attr} ||= val
+          end
+        SRC
+    end
+  end
+
+end

data/lib/sax-machine/sax_element_config.rb

@@ -0,0 +1,80 @@
+module SAXMachine
+  class SAXConfig
+    class ElementConfig
+      attr_reader :name, :setter, :data_class
+
+      def initialize(name, options)
+        @name = name.to_s
+
+        if options.has_key?(:with)
+          # for faster comparisons later
+          @with = options[:with].to_a.flatten.collect {|o| o.to_s}
+        else
+          @with = nil
+        end
+
+        if options.has_key?(:value)
+          @value = options[:value].to_s
+        else
+          @value = nil
+        end
+
+        @as = options[:as]
+        @collection = options[:collection]
+
+        if @collection
+          @setter = "add_#{options[:as]}"
+        else
+          @setter = "#{@as}="
+        end
+        @data_class = options[:class]
+        @required = options[:required]
+
+        @xmlns = case options[:xmlns]
+                 when Array then options[:xmlns]
+                 when String then [options[:xmlns]]
+                 else nil
+                 end
+      end
+
+      def column
+        @as || @name.to_sym
+      end
+
+      def required?
+        @required
+      end
+
+      def value_from_attrs(attrs)
+        pair = attrs.detect { |k, v| k == @value }
+        pair ? pair.last : nil
+      end
+
+      def attrs_match?(attrs)
+        if @with
+          if attrs.nil?
+            # If no attributes, match only if the :with clause is empty.
+            @with.empty?
+          else
+            # Attributes must match :with clause.
+            attrs.include?(@with)
+          end
+        else
+          true
+        end
+      end
+
+      def has_value_and_attrs_match?(attrs)
+        !@value.nil? && attrs_match?(attrs)
+      end
+
+      def xmlns_match?(ns)
+        @xmlns.nil? || @xmlns.include?(ns)
+      end
+
+      def collection?
+        @collection
+      end
+    end
+  end
+end