multi_xml 0.0.1 → 0.1.0

data/lib/multi_xml/parsers/nokogiri.rb

@@ -0,0 +1,79 @@
+require 'nokogiri' unless defined?(Nokogiri)
+
+module MultiXml
+  module Parsers
+    # Use Nokogiri to parse XML.
+    module Nokogiri #:nodoc:
+      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 #:nodoc:
+          CONTENT_ROOT = '__content__'.freeze unless defined?(CONTENT_ROOT)
+
+          # 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.
+            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
+
+            # Handle child elements
+            children.each do |c|
+              if c.element?
+                c.to_hash(node_hash)
+              elsif c.text? || c.cdata?
+                node_hash[CONTENT_ROOT] ||= ''
+                node_hash[CONTENT_ROOT] << c.content
+              end
+            end
+
+            # Remove content node if it is blank and there are child tags
+            if node_hash.length > 1 && (node_hash[CONTENT_ROOT].nil? || node_hash[CONTENT_ROOT].empty?)
+              node_hash.delete(CONTENT_ROOT)
+            end
+
+            # 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
+  end
+end

data/lib/multi_xml/parsers/rexml.rb

@@ -0,0 +1,127 @@
+require 'rexml/document' unless defined?(REXML::Document)
+
+module MultiXml
+  module Parsers
+    # Use REXML to parse XML.
+    module Rexml #:nodoc:
+      extend self
+
+      CONTENT_ROOT = '__content__'.freeze unless defined?(CONTENT_ROOT)
+
+      # Parse an XML Document string or IO into a simple hash
+      #
+      # 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 = 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_ROOT, 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.nil? || element.texts.join.empty?
+      end
+    end
+  end
+end

data/lib/multi_xml/version.rb

@@ -1,3 +1,3 @@
 module MultiXml
-  VERSION = "0.0.1"
+  VERSION = "0.1.0"
 end

data/multi_xml.gemspec

@@ -3,12 +3,11 @@ $:.push File.expand_path("../lib", __FILE__)
 require "multi_xml/version"
 
 Gem::Specification.new do |s|
-  s.add_development_dependency("bundler", ["~> 1.0.2"])
-  s.add_development_dependency("hpricot", ["~> 0.8.2"])
-  s.add_development_dependency("libxml-ruby", ["~> 1.1.4"])
-  s.add_development_dependency("nokogiri", ["~> 1.4.3"])
-  s.add_development_dependency("rake", ["~> 0.8.7"])
-  s.add_development_dependency("rspec", ["~> 1.3.0"])
+  s.add_development_dependency("bundler", "~> 1.0")
+  s.add_development_dependency("libxml-ruby", "~> 1.1")
+  s.add_development_dependency("nokogiri", "~> 1.4")
+  s.add_development_dependency("rake", "~> 0.8")
+  s.add_development_dependency("rspec", "~> 2.0")
   s.name        = "multi_xml"
   s.version     = MultiXml::VERSION
   s.platform    = Gem::Platform::RUBY

data/spec/multi_xml_spec.rb

@@ -7,42 +7,477 @@ class MockDecoder
 end
 
 describe "MultiXml" do
-  context 'engines' do
-    it 'should default to the best available gem' do
-      pending
+  context "Parsers" do
+    it "should default to the best available gem" do
       require 'libxml'
-      MultiXml.engine.name.should == 'MultiXml::Engines::Libxml'
+      MultiXml.parser.name.should == 'MultiXml::Parsers::Libxml'
     end
 
-    it 'should be settable via a symbol' do
-      pending
-      MultiXml.engine = :libxml
-      MultiXml.engine.name.should == 'MultiXml::Engines::Libxml'
+    it "should be settable via a symbol" do
+      MultiXml.parser = :libxml
+      MultiXml.parser.name.should == 'MultiXml::Parsers::Libxml'
     end
 
-    it 'should be settable via a class' do
-      MultiXml.engine = MockDecoder
-      MultiXml.engine.name.should == 'MockDecoder'
+    it "should be settable via a class" do
+      MultiXml.parser = MockDecoder
+      MultiXml.parser.name.should == 'MockDecoder'
     end
   end
 
-  %w(libxml nokogiri hpricot rexml).each do |engine|
-    context engine do
+  Dir.glob('lib/multi_xml/parsers/**/*.rb').map{|file| File.basename(file, ".rb").split('_').map{|s| s.capitalize}.join('')}.each do |parser|
+    context "Parsers::#{parser}" do
       before do
         begin
-          MultiXml.engine = engine
+          MultiXml.parser = parser
         rescue LoadError
-          pending "Engine #{engine} couldn't be loaded (not installed?)"
+          pending "Parser #{parser} couldn't be loaded"
         end
       end
 
-      describe '.parse' do
-        it 'should properly parse some XML' do
-          MultiXml.parse('<tag>This is the contents</tag>').should == {'tag' => 'This is the contents'}
+      describe ".parse" do
+        context "a blank string" do
+          before do
+            @string = ''
+          end
+
+          it "should return an empty Hash" do
+            MultiXml.parse(@string).should == {}
+          end
+        end
+
+        context "a whitespace string" do
+          before do
+            @string = ' '
+          end
+
+          it "should return an empty Hash" do
+            MultiXml.parse(@string).should == {}
+          end
+        end
+
+        context "a single-node document" do
+
+          before do
+            @string = '<user/>'
+          end
+
+          it "should parse correctly" do
+            MultiXml.parse(@string).should == {'user' => nil}
+          end
+
+          context "with CDATA" do
+            before do
+              @string = '<user><![CDATA[Erik Michaels-Ober]]></user>'
+            end
+
+            it "should parse correctly" do
+              MultiXml.parse(@string).should == {"user" => "Erik Michaels-Ober"}
+            end
+          end
+
+          context "with content" do
+            before do
+              @string = '<user>Erik Michaels-Ober</user>'
+            end
+
+            it "should parse correctly" do
+              MultiXml.parse(@string).should == {"user" => "Erik Michaels-Ober"}
+            end
+          end
+
+          context "with an attribute" do
+            before do
+              @string = '<user name="Erik Michaels-Ober"/>'
+            end
+
+            it "should parse correctly" do
+              MultiXml.parse(@string).should == {"user" => {"name" => "Erik Michaels-Ober"}}
+            end
+          end
+
+          context "with multiple attributes" do
+            before do
+              @string = '<user name="Erik Michaels-Ober" screen_name="sferik"/>'
+            end
+
+            it "should parse correctly" do
+              MultiXml.parse(@string).should == {"user" => {"name" => "Erik Michaels-Ober", "screen_name" => "sferik"}}
+            end
+          end
+
+          context "with :symbolize_keys => true" do
+            before do
+              @string = '<user name="Erik Michaels-Ober"/>'
+            end
+
+            it "should symbolize keys" do
+              MultiXml.parse(@string, :symbolize_keys => true).should == {:user => {:name => "Erik Michaels-Ober"}}
+            end
+          end
+
+          context "with an attribute type=\"boolean\"" do
+            %w(true false).each do |boolean|
+              context "when #{boolean}" do
+                it "should be #{boolean}" do
+                  string = "<tag type=\"boolean\">#{boolean}</tag>"
+                  MultiXml.parse(string)['tag'].should instance_eval("be_#{boolean}")
+                end
+              end
+            end
+
+            context "when 1" do
+              before do
+                @string = '<tag type="boolean">1</tag>'
+              end
+
+              it "should be true" do
+                MultiXml.parse(@string)['tag'].should be_true
+              end
+            end
+
+            context "when 0" do
+              before do
+                @string = '<tag type="boolean">0</tag>'
+              end
+
+              it "should be false" do
+                MultiXml.parse(@string)['tag'].should be_false
+              end
+            end
+          end
+
+          context "with an attribute type=\"integer\"" do
+            context "with a positive integer" do
+              before do
+                @string = '<tag type="integer">1</tag>'
+              end
+
+              it "should be a Fixnum" do
+                MultiXml.parse(@string)['tag'].should be_a(Fixnum)
+              end
+
+              it "should be the correct number" do
+                MultiXml.parse(@string)['tag'].should == 1
+              end
+            end
+
+            context "with a negative integer" do
+              before do
+                @string = '<tag type="integer">-1</tag>'
+              end
+
+              it "should be a Fixnum" do
+                MultiXml.parse(@string)['tag'].should be_a(Fixnum)
+              end
+
+              it "should be the correct number" do
+                MultiXml.parse(@string)['tag'].should == -1
+              end
+            end
+          end
+
+          context "with an attribute type=\"string\"" do
+            before do
+              @string = '<tag type="string"></tag>'
+            end
+
+            it "should be a String" do
+              MultiXml.parse(@string)['tag'].should be_a(String)
+            end
+
+            it "should be the correct string" do
+              MultiXml.parse(@string)['tag'].should == ""
+            end
+          end
+
+          context "with an attribute type=\"date\"" do
+            before do
+              @string = '<tag type="date">1970-01-01</tag>'
+            end
+
+            it "should be a Date" do
+              MultiXml.parse(@string)['tag'].should be_a(Date)
+            end
+
+            it "should be the correct date" do
+              MultiXml.parse(@string)['tag'].should == Date.parse('1970-01-01')
+            end
+          end
+
+          context "with an attribute type=\"datetime\"" do
+            before do
+              @string = '<tag type="datetime">1970-01-01 00:00</tag>'
+            end
+
+            it "should be a Time" do
+              MultiXml.parse(@string)['tag'].should be_a(Time)
+            end
+
+            it "should be the correct time" do
+              MultiXml.parse(@string)['tag'].should == Time.parse('1970-01-01 00:00')
+            end
+          end
+
+          context "with an attribute type=\"dateTime\"" do
+            before do
+              @string = '<tag type="datetime">1970-01-01 00:00</tag>'
+            end
+
+            it "should be a Time" do
+              MultiXml.parse(@string)['tag'].should be_a(Time)
+            end
+
+            it "should be the correct time" do
+              MultiXml.parse(@string)['tag'].should == Time.parse('1970-01-01 00:00')
+            end
+          end
+
+          context "with an attribute type=\"double\"" do
+            before do
+              @string = '<tag type="double">3.14159265358979</tag>'
+            end
+
+            it "should be a Float" do
+              MultiXml.parse(@string)['tag'].should be_a(Float)
+            end
+
+            it "should be the correct number" do
+              MultiXml.parse(@string)['tag'].should == 3.14159265358979
+            end
+          end
+
+          context "with an attribute type=\"decimal\"" do
+            before do
+              @string = '<tag type="decimal">3.14159265358979323846264338327950288419716939937510</tag>'
+            end
+
+            it "should be a BigDecimal" do
+              MultiXml.parse(@string)['tag'].should be_a(BigDecimal)
+            end
+
+            it "should be the correct number" do
+              MultiXml.parse(@string)['tag'].should == 3.14159265358979323846264338327950288419716939937510
+            end
+          end
+
+          context "with an attribute type=\"base64Binary\"" do
+            before do
+              @string = '<tag type="base64Binary">aW1hZ2UucG5n</tag>'
+            end
+
+            it "should be a String" do
+              MultiXml.parse(@string)['tag'].should be_a(String)
+            end
+
+            it "should be the correct string" do
+              MultiXml.parse(@string)['tag'].should == "image.png"
+            end
+          end
+
+          context "with an attribute type=\"yaml\"" do
+            before do
+              @string = "<tag type=\"yaml\">--- \n1: should be an integer\n:message: Have a nice day\narray: \n- should-have-dashes: true\n  should_have_underscores: true\n</tag>"
+            end
+
+            it "should parse correctly" do
+              MultiXml.parse(@string)['tag'].should == {:message => "Have a nice day", 1 => "should be an integer", "array" => [{"should-have-dashes" => true, "should_have_underscores" => true}]}
+            end
+          end
+
+          context "with an attribute type=\"file\"" do
+            before do
+              @string = '<tag type="file" name="data.txt" content_type="text/plain">ZGF0YQ==</tag>'
+            end
+
+            it "should be a StringIO" do
+              MultiXml.parse(@string)['tag'].should be_a(StringIO)
+            end
+
+            it "should be decoded correctly" do
+              MultiXml.parse(@string)['tag'].string.should == 'data'
+            end
+
+            it "should have the correct file name" do
+              MultiXml.parse(@string)['tag'].original_filename.should == 'data.txt'
+            end
+
+            it "should have the correct content type" do
+              MultiXml.parse(@string)['tag'].content_type.should == 'text/plain'
+            end
+
+            context "with missing name and content type" do
+              before do
+                @string = '<tag type="file">ZGF0YQ==</tag>'
+              end
+
+              it "should be a StringIO" do
+                MultiXml.parse(@string)['tag'].should be_a(StringIO)
+              end
+
+              it "should be decoded correctly" do
+                MultiXml.parse(@string)['tag'].string.should == 'data'
+              end
+
+              it "should have the default file name" do
+                MultiXml.parse(@string)['tag'].original_filename.should == 'untitled'
+              end
+
+              it "should have the default content type" do
+                MultiXml.parse(@string)['tag'].content_type.should == 'application/octet-stream'
+              end
+            end
+          end
+
+          context "with an unrecognized attribute type" do
+            before do
+              @string = '<tag type="foo"/>'
+            end
+
+            it "should pass through the type" do
+              pending
+              MultiXml.parse(@string)['tag']['type'].should == 'foo'
+            end
+          end
+
+          %w(integer boolean date datetime yaml).each do |type|
+            context "with an empty attribute type=\"#{type}\"" do
+              before do
+                @string = "<tag type=\"#{type}\"/>"
+              end
+
+              it "should be nil" do
+                MultiXml.parse(@string)['tag'].should be_nil
+              end
+            end
+          end
+
+          context "with an empty attribute type=\"array\"" do
+            before do
+              @string = '<users type="array"/>'
+            end
+
+            it "should be an empty Array" do
+              MultiXml.parse(@string)['users'].should == []
+            end
+
+            context "with whitespace" do
+              before do
+                @string = '<users type="array"> </users>'
+              end
+
+              it "should be an empty Array" do
+                MultiXml.parse(@string)['users'].should == []
+              end
+            end
+          end
+
+          context "with XML entities" do
+            before do
+              @xml_entities = {
+                "<" => "&lt;",
+                ">" => "&gt;",
+                '"' => "&quot;",
+                "'" => "&apos;",
+                "&" => "&amp;"
+              }
+            end
+
+            context "in content" do
+              it "should unescape XML entities" do
+                @xml_entities.each do |key, value|
+                  string = "<tag>#{value}</tag>"
+                  MultiXml.parse(string)['tag'].should == key
+                end
+              end
+            end
+
+            context "in attribute" do
+              it "should unescape XML entities" do
+                @xml_entities.each do |key, value|
+                  string = "<tag attribute=\"#{value}\"/>"
+                  MultiXml.parse(string)['tag']['attribute'].should == key
+                end
+              end
+            end
+          end
+
+          context "with dasherized tag" do
+            before do
+              @string = '<tag-1/>'
+            end
+
+            it "should undasherize tag" do
+              MultiXml.parse(@string).keys.should include('tag_1')
+            end
+          end
+
+          context "with dasherized attribute" do
+            before do
+              @string = '<tag attribute-1="1"></tag>'
+            end
+
+            it "should undasherize attribute" do
+              MultiXml.parse(@string)['tag'].keys.should include('attribute_1')
+            end
+          end
         end
 
-        it 'should allow for symbolization of keys' do
-          MultiXml.parse('<tag>This is the contents</tag>', :symbolize_keys => true).should == {:tag => 'This is the contents'}
+        context "a document" do
+          context "with :symbolize_keys => true" do
+            before do
+              @string = '<user><name>Erik Michaels-Ober</name></user>'
+            end
+
+            it "should symbolize keys" do
+              MultiXml.parse(@string, :symbolize_keys => true).should == {:user => {:name => "Erik Michaels-Ober"}}
+            end
+          end
+
+          context "with children" do
+            before do
+              @string = '<root><user name="Erik Michaels-Ober"/></root>'
+            end
+
+            it "should parse correctly" do
+              MultiXml.parse(@string).should == {"root" => {"user" => {"name"=>"Erik Michaels-Ober"}}}
+            end
+
+            context "with text" do
+              before do
+                @string = '<user><name>Erik Michaels-Ober</name></user>'
+              end
+
+              it "should parse correctly" do
+                MultiXml.parse(@string).should == {"user" => {"name" => "Erik Michaels-Ober"}}
+              end
+            end
+
+            # Babies having babies
+            context "with children" do
+              before do
+                @string = '<root><user name="Erik Michaels-Ober"><status text="Hello"/></user></root>'
+              end
+
+              it "should parse correctly" do
+                MultiXml.parse(@string).should == {"root" => {"user" => {"name" => "Erik Michaels-Ober", "status" => {"text" => "Hello"}}}}
+              end
+            end
+          end
+
+          context "with sibling children" do
+            before do
+              @string = '<root><users>Erik Michaels-Ober</users><users>Wynn Netherland</users></root>'
+            end
+
+            it "should parse correctly" do
+              MultiXml.parse(@string).should == {"root" => {"users" => ["Erik Michaels-Ober", "Wynn Netherland"]}}
+            end
+
+            it "should make an Array of children" do
+              MultiXml.parse(@string)['root']['users'].should be_a(Array)
+            end
+
+          end
         end
       end
     end