xml_mini 0.1.0

data/lib/xml_mini/libxml.rb

@@ -0,0 +1,63 @@
+require 'xml_mini/node_hash'
+
+module XmlMini_LibXML
+  extend self
+
+# Parse an XML Document string or IO into a simple hash using libxml.
+# data::
+#   XML Document string or IO to parse
+  def parse(data)
+    if !data.respond_to?(:read)
+      data = StringIO.new(data || '')
+    end
+
+    char = data.getc
+    if char.nil?
+      {}
+    else
+      data.ungetc(char)
+      LibXML::XML::Parser.io(data).parse.to_hash
+    end
+  end
+end
+
+module LibXML #:nodoc:
+  module Conversions #:nodoc:
+    module Document #:nodoc:
+      def to_hash
+        root.to_hash
+      end
+    end
+
+    module Node
+      include NodeHash
+
+      # Convert XML document to hash
+      #
+      # hash::
+      #   Hash to merge the converted element into.
+      def to_hash(hash={})
+        node_hash = {}
+
+        # Insert node hash into parent hash correctly.
+        insert_node_hash_into_parent(hash, name, node_hash)
+
+        # Handle child elements
+        each_child do |child|
+          handle_child_element(child, node_hash)
+        end
+
+        # Remove content node if it is blank
+        remove_blank_content_node node_hash
+
+        # Handle attributes
+        each_attr { |a| node_hash[a.name] = a.value }
+
+        hash
+      end
+    end
+  end
+end
+
+LibXML::XML::Document.send(:include, LibXML::Conversions::Document)
+LibXML::XML::Node.send(:include, LibXML::Conversions::Node)

data/lib/xml_mini/libxmlsax.rb

@@ -0,0 +1,84 @@
+require 'stringio'
+
+module XmlMini_LibXMLSAX
+  extend self
+
+  # Class that will build the hash while the XML document
+  # is being parsed using SAX events.
+  class HashBuilder
+
+    include LibXML::XML::SaxParser::Callbacks
+
+    CONTENT_KEY = '__content__'.freeze
+    HASH_SIZE_KEY = '__hash_size__'.freeze
+
+    attr_reader :hash
+
+    def current_hash
+      @hash_stack.last
+    end
+
+    def on_start_document
+      @hash = {CONTENT_KEY => ''}
+      @hash_stack = [@hash]
+    end
+
+    def on_end_document
+      @hash = @hash_stack.pop
+      @hash.delete(CONTENT_KEY)
+    end
+
+    def on_start_element(name, attrs = {})
+      new_hash = {CONTENT_KEY => ''}.merge(attrs)
+      new_hash[HASH_SIZE_KEY] = new_hash.size + 1
+
+      case current_hash[name]
+        when Array then
+          current_hash[name] << new_hash
+        when Hash then
+          current_hash[name] = [current_hash[name], new_hash]
+        when nil then
+          current_hash[name] = new_hash
+      end
+
+      @hash_stack.push(new_hash)
+    end
+
+    def on_end_element(name)
+      if current_hash.length > current_hash.delete(HASH_SIZE_KEY) && current_hash[CONTENT_KEY].blank? || current_hash[CONTENT_KEY] == ''
+        current_hash.delete(CONTENT_KEY)
+      end
+      @hash_stack.pop
+    end
+
+    def on_characters(string)
+      current_hash[CONTENT_KEY] << string
+    end
+
+    alias_method :on_cdata_block, :on_characters
+  end
+
+  attr_accessor :document_class
+  self.document_class = HashBuilder
+
+  def parse(data)
+    if !data.respond_to?(:read)
+      data = StringIO.new(data || '')
+    end
+
+    char = data.getc
+    if char.nil?
+      {}
+    else
+      data.ungetc(char)
+
+      LibXML::XML::Error.set_handler(&LibXML::XML::Error::QUIET_HANDLER)
+      parser = LibXML::XML::SaxParser.io(data)
+      document = self.document_class.new
+
+      parser.callbacks = document
+      parser.parse
+      document.hash
+    end
+  end
+end

data/lib/xml_mini/node_hash.rb

@@ -0,0 +1,29 @@
+module NodeHash
+  CONTENT_ROOT = '__content__'.freeze
+
+  def insert_node_hash_into_parent(hash, name, node_hash)
+    case hash[name]
+      when Array then
+        hash[name] << node_hash
+      when Hash then
+        hash[name] = [hash[name], node_hash]
+      when nil then
+        hash[name] = node_hash
+    end
+  end
+
+  def handle_child_element(child, node_hash)
+    if child.element?
+      child.to_hash(node_hash)
+    elsif child.text? || child.cdata?
+      node_hash[CONTENT_ROOT] ||= ''
+      node_hash[CONTENT_ROOT] << child.content
+    end
+  end
+
+  def remove_blank_content_node(node_hash)
+    if node_hash.length > 1 && node_hash[CONTENT_ROOT].blank?
+      node_hash.delete(CONTENT_ROOT)
+    end
+  end
+end

data/lib/xml_mini/nokogiri.rb

@@ -0,0 +1,64 @@
+require 'stringio'
+require 'xml_mini/node_hash'
+
+module XmlMini_Nokogiri
+  extend self
+
+# Parse an XML Document string or IO into a simple hash using libxml / nokogiri.
+# data::
+#   XML Document string or IO to parse
+  def parse(data)
+    if !data.respond_to?(:read)
+      data = StringIO.new(data || '')
+    end
+
+    char = data.getc
+    if char.nil?
+      {}
+    else
+      data.ungetc(char)
+      doc = Nokogiri::XML(data)
+      raise doc.errors.first if doc.errors.length > 0
+      doc.to_hash
+    end
+  end
+
+  module Conversions #:nodoc:
+    module Document #:nodoc:
+      def to_hash
+        root.to_hash
+      end
+    end
+
+    module Node
+      include NodeHash
+
+      # Convert XML document to hash
+      #
+      # hash::
+      #   Hash to merge the converted element into.
+      def to_hash(hash={})
+        node_hash = {}
+
+        # Insert node hash into parent hash correctly.
+        insert_node_hash_into_parent(hash, name, node_hash)
+
+        # Handle child elements
+        children.each do |child|
+          handle_child_element(child, node_hash)
+        end
+
+        # Remove content node if it is empty and there are child tags
+        remove_blank_content_node node_hash
+
+        # Handle attributes
+        attribute_nodes.each { |a| node_hash[a.node_name] = a.value }
+
+        hash
+      end
+    end
+  end
+
+  Nokogiri::XML::Document.send(:include, Conversions::Document)
+  Nokogiri::XML::Node.send(:include, Conversions::Node)
+end

data/lib/xml_mini/nokogirisax.rb

@@ -0,0 +1,81 @@
+require 'stringio'
+
+module XmlMini_NokogiriSAX
+  extend self
+
+  # Class that will build the hash while the XML document
+  # is being parsed using SAX events.
+  class HashBuilder < Nokogiri::XML::SAX::Document
+
+    CONTENT_KEY = '__content__'.freeze
+    HASH_SIZE_KEY = '__hash_size__'.freeze
+
+    attr_reader :hash
+
+    def current_hash
+      @hash_stack.last
+    end
+
+    def start_document
+      @hash = {}
+      @hash_stack = [@hash]
+    end
+
+    def end_document
+      raise "Parse stack not empty!" if @hash_stack.size > 1
+    end
+
+    def error(error_message)
+      raise error_message
+    end
+
+    def start_element(name, attrs = [])
+      new_hash = {CONTENT_KEY => ''}.merge(Hash[attrs])
+      new_hash[HASH_SIZE_KEY] = new_hash.size + 1
+
+      case current_hash[name]
+        when Array then
+          current_hash[name] << new_hash
+        when Hash then
+          current_hash[name] = [current_hash[name], new_hash]
+        when nil then
+          current_hash[name] = new_hash
+      end
+
+      @hash_stack.push(new_hash)
+    end
+
+    def end_element(name)
+      if current_hash.length > current_hash.delete(HASH_SIZE_KEY) && current_hash[CONTENT_KEY].blank? || current_hash[CONTENT_KEY] == ''
+        current_hash.delete(CONTENT_KEY)
+      end
+      @hash_stack.pop
+    end
+
+    def characters(string)
+      current_hash[CONTENT_KEY] << string
+    end
+
+    alias_method :cdata_block, :characters
+  end
+
+  attr_accessor :document_class
+  self.document_class = HashBuilder
+
+  def parse(data)
+    if !data.respond_to?(:read)
+      data = StringIO.new(data || '')
+    end
+
+    char = data.getc
+    if char.nil?
+      {}
+    else
+      data.ungetc(char)
+      document = self.document_class.new
+      parser = Nokogiri::XML::SAX::Parser.new(document)
+      parser.parse(data)
+      document.hash
+    end
+  end
+end

data/lib/xml_mini/rexml.rb

@@ -0,0 +1,126 @@
+require 'stringio'
+
+module XmlMini_REXML
+  extend self
+
+  CONTENT_KEY = '__content__'.freeze
+
+  # Parse an XML Document string or IO into a simple hash
+  #
+  # Same as XmlSimple::xml_in but doesn't shoot itself in the foot,
+  # and uses the defaults from Active Support.
+  #
+  # data::
+  #   XML Document string or IO to parse
+  def parse(data)
+    if !data.respond_to?(:read)
+      data = StringIO.new(data || '')
+    end
+
+    char = data.getc
+    if char.nil?
+      {}
+    else
+      data.ungetc(char)
+      require 'rexml/document' unless defined?(REXML::Document)
+      doc = REXML::Document.new(data)
+
+      if doc.root
+        merge_element!({}, doc.root)
+      else
+        raise REXML::ParseException,
+              "The document #{doc.to_s.inspect} does not have a valid root"
+      end
+    end
+  end
+
+  private
+
+  # Convert an XML element and merge into the hash
+  #
+  # hash::
+  #   Hash to merge the converted element into.
+  # element::
+  #   XML element to merge into hash
+  def merge_element!(hash, element)
+    merge!(hash, element.name, collapse(element))
+  end
+
+  # Actually converts an XML document element into a data structure.
+  #
+  # element::
+  #   The document element to be collapsed.
+  def collapse(element)
+    hash = get_attributes(element)
+
+    if element.has_elements?
+      element.each_element { |child| merge_element!(hash, child) }
+      merge_texts!(hash, element) unless empty_content?(element)
+      hash
+    else
+      merge_texts!(hash, element)
+    end
+  end
+
+  # Merge all the texts of an element into the hash
+  #
+  # hash::
+  #   Hash to add the converted element to.
+  # element::
+  #   XML element whose texts are to me merged into the hash
+  def merge_texts!(hash, element)
+    unless element.has_text?
+      hash
+    else
+      # must use value to prevent double-escaping
+      texts = ''
+      element.texts.each { |t| texts << t.value }
+      merge!(hash, CONTENT_KEY, texts)
+    end
+  end
+
+  # Adds a new key/value pair to an existing Hash. If the key to be added
+  # already exists and the existing value associated with key is not
+  # an Array, it will be wrapped in an Array. Then the new value is
+  # appended to that Array.
+  #
+  # hash::
+  #   Hash to add key/value pair to.
+  # key::
+  #   Key to be added.
+  # value::
+  #   Value to be associated with key.
+  def merge!(hash, key, value)
+    if hash.has_key?(key)
+      if hash[key].instance_of?(Array)
+        hash[key] << value
+      else
+        hash[key] = [hash[key], value]
+      end
+    elsif value.instance_of?(Array)
+      hash[key] = [value]
+    else
+      hash[key] = value
+    end
+    hash
+  end
+
+  # Converts the attributes array of an XML element into a hash.
+  # Returns an empty Hash if node has no attributes.
+  #
+  # element::
+  #   XML element to extract attributes from.
+  def get_attributes(element)
+    attributes = {}
+    element.attributes.each { |n, v| attributes[n] = v }
+    attributes
+  end
+
+  # Determines if a document element has text content
+  #
+  # element::
+  #   XML element to be checked.
+  def empty_content?(element)
+    element.texts.join.blank?
+  end
+end