multi_xml 0.1.0 → 0.1.1

data/.rspec

@@ -1,2 +1,3 @@
 --color
 --format=nested
+--backtrace

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    multi_xml (0.1.0)
+    multi_xml (0.1.1)
 
 GEM
   remote: http://rubygems.org/

data/README.rdoc

@@ -1,4 +1,5 @@
 = MultiXML
+==== A generic swappable back-end for XML parsing
 
 Lots of Ruby libraries utilize XML parsing in some form, and everyone has their favorite XML library. In order to best support multiple XML parsers and libraries, <tt>multi_xml</tt> is a general-purpose swappable XML backend library. You use it like so:
 

data/lib/multi_xml.rb

@@ -20,8 +20,8 @@ module MultiXml
     unless defined?(PARSING)
       PARSING = {
         'symbol'       => Proc.new{|symbol| symbol.to_sym},
-        'date'         => Proc.new{|date| ::Date.parse(date)},
-        'datetime'     => Proc.new{|time| ::Time.parse(time).utc rescue ::DateTime.parse(time).utc},
+        'date'         => Proc.new{|date| Date.parse(date)},
+        'datetime'     => Proc.new{|time| Time.parse(time).utc rescue DateTime.parse(time).utc},
         'integer'      => Proc.new{|integer| integer.to_i},
         'float'        => Proc.new{|float| float.to_f},
         'decimal'      => Proc.new{|number| BigDecimal(number)},
@@ -89,9 +89,8 @@ module MultiXml
     # <tt>:symbolize_keys</tt> :: If true, will use symbols instead of strings for the keys.
     def parse(xml, options={})
       xml.strip!
-      hash = typecast_xml_value(undasherize_keys(parser.parse(xml)))
+      hash = typecast_xml_value(undasherize_keys(parser.parse(xml))) || {}
       hash = symbolize_keys(hash) if options[:symbolize_keys]
-      hash = {} if hash.nil?
       hash
     end
 
@@ -177,7 +176,7 @@ module MultiXml
       when Hash
         if value['type'] == 'array'
           _, entries = wrap(value.detect{|key, value| key != 'type'})
-          if entries.nil? || entries.strip == '' || (c = value[CONTENT_ROOT] && c.nil?)
+          if entries.blank? || (c = value[CONTENT_ROOT] && c.blank?)
             []
           else
             case entries
@@ -199,12 +198,12 @@ module MultiXml
         elsif value['type'] == 'string' && value['nil'] != 'true'
           ''
         # blank or nil parsed values are represented by nil
-        elsif value.nil? || value.empty? || value['nil'] == 'true'
+        elsif value.blank? || value['nil'] == 'true'
           nil
         # If the type is the only element which makes it then
         # this still makes the value nil, except if type is
         # a XML node(where type['value'] is a Hash)
-        elsif value['type'] && value.size == 1 && !value['type'].is_a?(::Hash)
+        elsif value['type'] && value.size == 1 && !value['type'].is_a?(Hash)
           nil
         else
           xml_value = value.inject({}) do |hash, (key, value)|
@@ -227,3 +226,8 @@ module MultiXml
     end
   end
 end
+
+library_files = Dir[File.join(File.dirname(__FILE__), "/multi_xml/**/*.rb")].sort
+library_files.each do |file|
+  require file
+end

data/lib/multi_xml/core_extensions.rb

@@ -0,0 +1,59 @@
+class Object #:nodoc:
+  # @return <TrueClass, FalseClass>
+  #
+  # @example [].blank?         #=>  true
+  # @example [1].blank?        #=>  false
+  # @example [nil].blank?      #=>  false
+  # 
+  # Returns true if the object is nil or empty (if applicable)
+  def blank?
+    nil? || (respond_to?(:empty?) && empty?)
+  end
+end
+
+class Numeric #:nodoc:
+  # @return <TrueClass, FalseClass>
+  # 
+  # Numerics can't be blank
+  def blank?
+    false
+  end
+end
+
+class NilClass #:nodoc:
+  # @return <TrueClass, FalseClass>
+  # 
+  # Nils are always blank
+  def blank?
+    true
+  end
+end
+
+class TrueClass #:nodoc:
+  # @return <TrueClass, FalseClass>
+  # 
+  # True is not blank.  
+  def blank?
+    false
+  end
+end
+
+class FalseClass #:nodoc:
+  # False is always blank.
+  def blank?
+    true
+  end
+end
+
+class String #:nodoc:
+  # @example "".blank?         #=>  true
+  # @example "     ".blank?    #=>  true
+  # @example " hey ho ".blank? #=>  false
+  # 
+  # @return <TrueClass, FalseClass>
+  # 
+  # Strips out whitespace then tests if the string is empty.
+  def blank?
+    strip.empty?
+  end
+end

data/lib/multi_xml/parsers/libxml.rb

@@ -7,19 +7,19 @@ module MultiXml
       extend self
 
       # Parse an XML Document string or IO into a simple hash using libxml.
-      # data::
+      # xml::
       #   XML Document string or IO to parse
-      def parse(data)
-        if !data.respond_to?(:read)
-          data = StringIO.new(data || '')
+      def parse(xml)
+        if !xml.respond_to?(:read)
+          xml = StringIO.new(xml || '')
         end
 
-        char = data.getc
+        char = xml.getc
         if char.nil?
           {}
         else
-          data.ungetc(char)
-          LibXML::XML::Parser.io(data).parse.to_hash
+          xml.ungetc(char)
+          LibXML::XML::Parser.io(xml).parse.to_hash
         end
       end
     end
@@ -62,7 +62,7 @@ module LibXML #:nodoc:
         end
 
         # Remove content node if it is blank
-        if node_hash.length > 1 && (node_hash[CONTENT_ROOT].nil? || node_hash[CONTENT_ROOT].empty?)
+        if node_hash.length > 1 && node_hash[CONTENT_ROOT].blank?
           node_hash.delete(CONTENT_ROOT)
         end
 

data/lib/multi_xml/parsers/nokogiri.rb

@@ -7,19 +7,19 @@ module MultiXml
       extend self
 
       # Parse an XML Document string or IO into a simple hash using libxml / nokogiri.
-      # data::
+      # xml::
       #   XML Document string or IO to parse
-      def parse(data)
-        if !data.respond_to?(:read)
-          data = StringIO.new(data || '')
+      def parse(xml)
+        if !xml.respond_to?(:read)
+          xml = StringIO.new(xml || '')
         end
 
-        char = data.getc
+        char = xml.getc
         if char.nil?
           {}
         else
-          data.ungetc(char)
-          doc = ::Nokogiri::XML(data)
+          xml.ungetc(char)
+          doc = ::Nokogiri::XML(xml)
           raise doc.errors.first if doc.errors.length > 0
           doc.to_hash
         end
@@ -60,7 +60,7 @@ module MultiXml
             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?)
+            if node_hash.length > 1 && node_hash[CONTENT_ROOT].blank?
               node_hash.delete(CONTENT_ROOT)
             end
 

data/lib/multi_xml/parsers/rexml.rb

@@ -10,25 +10,23 @@ module MultiXml
 
       # Parse an XML Document string or IO into a simple hash
       #
-      # data::
+      # xml::
       #   XML Document string or IO to parse
-      def parse(data)
-        if !data.respond_to?(:read)
-          data = StringIO.new(data || '')
+      def parse(xml)
+        if !xml.respond_to?(:read)
+          xml = StringIO.new(xml || '')
         end
 
-        char = data.getc
+        char = xml.getc
         if char.nil?
           {}
         else
-          data.ungetc(char)
-          doc = REXML::Document.new(data)
-
+          xml.ungetc(char)
+          doc = REXML::Document.new(xml)
           if doc.root
             merge_element!({}, doc.root)
           else
-            raise REXML::ParseException,
-              "The document #{doc.to_s.inspect} does not have a valid root"
+            raise REXML::ParseException, "The document #{doc.to_s.inspect} does not have a valid root"
           end
         end
       end
@@ -120,7 +118,7 @@ module MultiXml
       # element::
       #   XML element to be checked.
       def empty_content?(element)
-        element.texts.join.nil? || element.texts.join.empty?
+        element.texts.join.blank?
       end
     end
   end

data/lib/multi_xml/version.rb

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

data/multi_xml.gemspec

@@ -14,8 +14,8 @@ Gem::Specification.new do |s|
   s.authors     = ["Erik Michaels-Ober"]
   s.email       = ["sferik@gmail.com"]
   s.homepage    = "http://rubygems.org/gems/multi_xml"
-  s.summary     = %q{A gem to provide swappable XML backends utilizing LibXML, Nokogiri, Hpricot, or REXML.}
-  s.description = s.summary
+  s.summary     = %q{A generic swappable back-end for XML parsing}
+  s.description = %q{A gem to provide swappable XML backends utilizing LibXML, Nokogiri, or REXML.}
   s.rubyforge_project = "multi_xml"
   s.files         = `git ls-files`.split("\n")
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")

data/spec/multi_xml_spec.rb

@@ -1,7 +1,7 @@
 require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 
 class MockDecoder
-  def self.parse(string)
+  def self.parse(xml)
     '<tag>This is the contents</tag>'
   end
 end
@@ -37,81 +37,81 @@ describe "MultiXml" do
       describe ".parse" do
         context "a blank string" do
           before do
-            @string = ''
+            @xml = ''
           end
 
           it "should return an empty Hash" do
-            MultiXml.parse(@string).should == {}
+            MultiXml.parse(@xml).should == {}
           end
         end
 
         context "a whitespace string" do
           before do
-            @string = ' '
+            @xml = ' '
           end
 
           it "should return an empty Hash" do
-            MultiXml.parse(@string).should == {}
+            MultiXml.parse(@xml).should == {}
           end
         end
 
         context "a single-node document" do
 
           before do
-            @string = '<user/>'
+            @xml = '<user/>'
           end
 
           it "should parse correctly" do
-            MultiXml.parse(@string).should == {'user' => nil}
+            MultiXml.parse(@xml).should == {'user' => nil}
           end
 
           context "with CDATA" do
             before do
-              @string = '<user><![CDATA[Erik Michaels-Ober]]></user>'
+              @xml = '<user><![CDATA[Erik Michaels-Ober]]></user>'
             end
 
             it "should parse correctly" do
-              MultiXml.parse(@string).should == {"user" => "Erik Michaels-Ober"}
+              MultiXml.parse(@xml).should == {"user" => "Erik Michaels-Ober"}
             end
           end
 
           context "with content" do
             before do
-              @string = '<user>Erik Michaels-Ober</user>'
+              @xml = '<user>Erik Michaels-Ober</user>'
             end
 
             it "should parse correctly" do
-              MultiXml.parse(@string).should == {"user" => "Erik Michaels-Ober"}
+              MultiXml.parse(@xml).should == {"user" => "Erik Michaels-Ober"}
             end
           end
 
           context "with an attribute" do
             before do
-              @string = '<user name="Erik Michaels-Ober"/>'
+              @xml = '<user name="Erik Michaels-Ober"/>'
             end
 
             it "should parse correctly" do
-              MultiXml.parse(@string).should == {"user" => {"name" => "Erik Michaels-Ober"}}
+              MultiXml.parse(@xml).should == {"user" => {"name" => "Erik Michaels-Ober"}}
             end
           end
 
           context "with multiple attributes" do
             before do
-              @string = '<user name="Erik Michaels-Ober" screen_name="sferik"/>'
+              @xml = '<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"}}
+              MultiXml.parse(@xml).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"/>'
+              @xml = '<user name="Erik Michaels-Ober"/>'
             end
 
             it "should symbolize keys" do
-              MultiXml.parse(@string, :symbolize_keys => true).should == {:user => {:name => "Erik Michaels-Ober"}}
+              MultiXml.parse(@xml, :symbolize_keys => true).should == {:user => {:name => "Erik Michaels-Ober"}}
             end
           end
 
@@ -119,29 +119,29 @@ describe "MultiXml" 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}")
+                  xml = "<tag type=\"boolean\">#{boolean}</tag>"
+                  MultiXml.parse(xml)['tag'].should instance_eval("be_#{boolean}")
                 end
               end
             end
 
             context "when 1" do
               before do
-                @string = '<tag type="boolean">1</tag>'
+                @xml = '<tag type="boolean">1</tag>'
               end
 
               it "should be true" do
-                MultiXml.parse(@string)['tag'].should be_true
+                MultiXml.parse(@xml)['tag'].should be_true
               end
             end
 
             context "when 0" do
               before do
-                @string = '<tag type="boolean">0</tag>'
+                @xml = '<tag type="boolean">0</tag>'
               end
 
               it "should be false" do
-                MultiXml.parse(@string)['tag'].should be_false
+                MultiXml.parse(@xml)['tag'].should be_false
               end
             end
           end
@@ -149,224 +149,213 @@ describe "MultiXml" do
           context "with an attribute type=\"integer\"" do
             context "with a positive integer" do
               before do
-                @string = '<tag type="integer">1</tag>'
+                @xml = '<tag type="integer">1</tag>'
               end
 
               it "should be a Fixnum" do
-                MultiXml.parse(@string)['tag'].should be_a(Fixnum)
+                MultiXml.parse(@xml)['tag'].should be_a(Fixnum)
               end
 
               it "should be the correct number" do
-                MultiXml.parse(@string)['tag'].should == 1
+                MultiXml.parse(@xml)['tag'].should == 1
               end
             end
 
             context "with a negative integer" do
               before do
-                @string = '<tag type="integer">-1</tag>'
+                @xml = '<tag type="integer">-1</tag>'
               end
 
               it "should be a Fixnum" do
-                MultiXml.parse(@string)['tag'].should be_a(Fixnum)
+                MultiXml.parse(@xml)['tag'].should be_a(Fixnum)
               end
 
               it "should be the correct number" do
-                MultiXml.parse(@string)['tag'].should == -1
+                MultiXml.parse(@xml)['tag'].should == -1
               end
             end
           end
 
           context "with an attribute type=\"string\"" do
             before do
-              @string = '<tag type="string"></tag>'
+              @xml = '<tag type="string"></tag>'
             end
 
             it "should be a String" do
-              MultiXml.parse(@string)['tag'].should be_a(String)
+              MultiXml.parse(@xml)['tag'].should be_a(String)
             end
 
             it "should be the correct string" do
-              MultiXml.parse(@string)['tag'].should == ""
+              MultiXml.parse(@xml)['tag'].should == ""
             end
           end
 
           context "with an attribute type=\"date\"" do
             before do
-              @string = '<tag type="date">1970-01-01</tag>'
+              @xml = '<tag type="date">1970-01-01</tag>'
             end
 
             it "should be a Date" do
-              MultiXml.parse(@string)['tag'].should be_a(Date)
+              MultiXml.parse(@xml)['tag'].should be_a(Date)
             end
 
             it "should be the correct date" do
-              MultiXml.parse(@string)['tag'].should == Date.parse('1970-01-01')
+              MultiXml.parse(@xml)['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>'
+              @xml = '<tag type="datetime">1970-01-01 00:00</tag>'
             end
 
             it "should be a Time" do
-              MultiXml.parse(@string)['tag'].should be_a(Time)
+              MultiXml.parse(@xml)['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')
+              MultiXml.parse(@xml)['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>'
+              @xml = '<tag type="datetime">1970-01-01 00:00</tag>'
             end
 
             it "should be a Time" do
-              MultiXml.parse(@string)['tag'].should be_a(Time)
+              MultiXml.parse(@xml)['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')
+              MultiXml.parse(@xml)['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>'
+              @xml = '<tag type="double">3.14159265358979</tag>'
             end
 
             it "should be a Float" do
-              MultiXml.parse(@string)['tag'].should be_a(Float)
+              MultiXml.parse(@xml)['tag'].should be_a(Float)
             end
 
             it "should be the correct number" do
-              MultiXml.parse(@string)['tag'].should == 3.14159265358979
+              MultiXml.parse(@xml)['tag'].should == 3.14159265358979
             end
           end
 
           context "with an attribute type=\"decimal\"" do
             before do
-              @string = '<tag type="decimal">3.14159265358979323846264338327950288419716939937510</tag>'
+              @xml = '<tag type="decimal">3.14159265358979323846264338327950288419716939937510</tag>'
             end
 
             it "should be a BigDecimal" do
-              MultiXml.parse(@string)['tag'].should be_a(BigDecimal)
+              MultiXml.parse(@xml)['tag'].should be_a(BigDecimal)
             end
 
             it "should be the correct number" do
-              MultiXml.parse(@string)['tag'].should == 3.14159265358979323846264338327950288419716939937510
+              MultiXml.parse(@xml)['tag'].should == 3.14159265358979323846264338327950288419716939937510
             end
           end
 
           context "with an attribute type=\"base64Binary\"" do
             before do
-              @string = '<tag type="base64Binary">aW1hZ2UucG5n</tag>'
+              @xml = '<tag type="base64Binary">aW1hZ2UucG5n</tag>'
             end
 
             it "should be a String" do
-              MultiXml.parse(@string)['tag'].should be_a(String)
+              MultiXml.parse(@xml)['tag'].should be_a(String)
             end
 
             it "should be the correct string" do
-              MultiXml.parse(@string)['tag'].should == "image.png"
+              MultiXml.parse(@xml)['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>"
+              @xml = "<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}]}
+              MultiXml.parse(@xml)['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>'
+              @xml = '<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)
+              MultiXml.parse(@xml)['tag'].should be_a(StringIO)
             end
 
             it "should be decoded correctly" do
-              MultiXml.parse(@string)['tag'].string.should == 'data'
+              MultiXml.parse(@xml)['tag'].string.should == 'data'
             end
 
             it "should have the correct file name" do
-              MultiXml.parse(@string)['tag'].original_filename.should == 'data.txt'
+              MultiXml.parse(@xml)['tag'].original_filename.should == 'data.txt'
             end
 
             it "should have the correct content type" do
-              MultiXml.parse(@string)['tag'].content_type.should == 'text/plain'
+              MultiXml.parse(@xml)['tag'].content_type.should == 'text/plain'
             end
 
             context "with missing name and content type" do
               before do
-                @string = '<tag type="file">ZGF0YQ==</tag>'
+                @xml = '<tag type="file">ZGF0YQ==</tag>'
               end
 
               it "should be a StringIO" do
-                MultiXml.parse(@string)['tag'].should be_a(StringIO)
+                MultiXml.parse(@xml)['tag'].should be_a(StringIO)
               end
 
               it "should be decoded correctly" do
-                MultiXml.parse(@string)['tag'].string.should == 'data'
+                MultiXml.parse(@xml)['tag'].string.should == 'data'
               end
 
               it "should have the default file name" do
-                MultiXml.parse(@string)['tag'].original_filename.should == 'untitled'
+                MultiXml.parse(@xml)['tag'].original_filename.should == 'untitled'
               end
 
               it "should have the default content type" do
-                MultiXml.parse(@string)['tag'].content_type.should == 'application/octet-stream'
+                MultiXml.parse(@xml)['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}\"/>"
+                @xml = "<tag type=\"#{type}\"/>"
               end
 
               it "should be nil" do
-                MultiXml.parse(@string)['tag'].should be_nil
+                MultiXml.parse(@xml)['tag'].should be_nil
               end
             end
           end
 
           context "with an empty attribute type=\"array\"" do
             before do
-              @string = '<users type="array"/>'
+              @xml = '<users type="array"/>'
             end
 
             it "should be an empty Array" do
-              MultiXml.parse(@string)['users'].should == []
+              MultiXml.parse(@xml)['users'].should == []
             end
 
             context "with whitespace" do
               before do
-                @string = '<users type="array"> </users>'
+                @xml = '<users type="array"> </users>'
               end
 
               it "should be an empty Array" do
-                MultiXml.parse(@string)['users'].should == []
+                MultiXml.parse(@xml)['users'].should == []
               end
             end
           end
@@ -385,8 +374,8 @@ describe "MultiXml" do
             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
+                  xml = "<tag>#{value}</tag>"
+                  MultiXml.parse(xml)['tag'].should == key
                 end
               end
             end
@@ -394,8 +383,8 @@ describe "MultiXml" do
             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
+                  xml = "<tag attribute=\"#{value}\"/>"
+                  MultiXml.parse(xml)['tag']['attribute'].should == key
                 end
               end
             end
@@ -403,21 +392,21 @@ describe "MultiXml" do
 
           context "with dasherized tag" do
             before do
-              @string = '<tag-1/>'
+              @xml = '<tag-1/>'
             end
 
             it "should undasherize tag" do
-              MultiXml.parse(@string).keys.should include('tag_1')
+              MultiXml.parse(@xml).keys.should include('tag_1')
             end
           end
 
           context "with dasherized attribute" do
             before do
-              @string = '<tag attribute-1="1"></tag>'
+              @xml = '<tag attribute-1="1"></tag>'
             end
 
             it "should undasherize attribute" do
-              MultiXml.parse(@string)['tag'].keys.should include('attribute_1')
+              MultiXml.parse(@xml)['tag'].keys.should include('attribute_1')
             end
           end
         end
@@ -425,56 +414,80 @@ describe "MultiXml" do
         context "a document" do
           context "with :symbolize_keys => true" do
             before do
-              @string = '<user><name>Erik Michaels-Ober</name></user>'
+              @xml = '<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"}}
+              MultiXml.parse(@xml, :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>'
+              @xml = '<root><user name="Erik Michaels-Ober"/></root>'
             end
 
             it "should parse correctly" do
-              MultiXml.parse(@string).should == {"root" => {"user" => {"name"=>"Erik Michaels-Ober"}}}
+              MultiXml.parse(@xml).should == {"root" => {"user" => {"name"=>"Erik Michaels-Ober"}}}
             end
 
             context "with text" do
               before do
-                @string = '<user><name>Erik Michaels-Ober</name></user>'
+                @xml = '<user><name>Erik Michaels-Ober</name></user>'
+              end
+
+              it "should parse correctly" do
+                MultiXml.parse(@xml).should == {"user" => {"name" => "Erik Michaels-Ober"}}
+              end
+            end
+
+            context "with an unrecognized attribute type" do
+              before do
+                @xml = '<user type="admin"><name>Erik Michaels-Ober</name></user>'
+              end
+
+              it "should pass through the type" do
+                MultiXml.parse(@xml)['user']['type'].should == 'admin'
+              end
+            end
+
+            context "with newlines and whitespace" do
+              before do
+                @xml = <<-XML
+                  <user>
+                    <name>Erik Michaels-Ober</name>
+                  </user>
+                XML
               end
 
               it "should parse correctly" do
-                MultiXml.parse(@string).should == {"user" => {"name" => "Erik Michaels-Ober"}}
+                MultiXml.parse(@xml).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>'
+                @xml = '<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"}}}}
+                MultiXml.parse(@xml).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>'
+              @xml = '<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"]}}
+              MultiXml.parse(@xml).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)
+            it "should be Array" do
+              MultiXml.parse(@xml)['root']['users'].should be_a(Array)
             end
 
           end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: multi_xml
 version: !ruby/object:Gem::Version 
-  hash: 27
+  hash: 25
   prerelease: false
   segments: 
   - 0
   - 1
-  - 0
-  version: 0.1.0
+  - 1
+  version: 0.1.1
 platform: ruby
 authors: 
 - Erik Michaels-Ober
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-10-12 00:00:00 -07:00
+date: 2010-10-16 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -93,7 +93,7 @@ dependencies:
         version: "2.0"
   type: :development
   version_requirements: *id005
-description: A gem to provide swappable XML backends utilizing LibXML, Nokogiri, Hpricot, or REXML.
+description: A gem to provide swappable XML backends utilizing LibXML, Nokogiri, or REXML.
 email: 
 - sferik@gmail.com
 executables: []
@@ -111,6 +111,7 @@ files:
 - README.rdoc
 - Rakefile
 - lib/multi_xml.rb
+- lib/multi_xml/core_extensions.rb
 - lib/multi_xml/parsers/libxml.rb
 - lib/multi_xml/parsers/nokogiri.rb
 - lib/multi_xml/parsers/rexml.rb
@@ -151,7 +152,7 @@ rubyforge_project: multi_xml
 rubygems_version: 1.3.7
 signing_key: 
 specification_version: 3
-summary: A gem to provide swappable XML backends utilizing LibXML, Nokogiri, Hpricot, or REXML.
+summary: A generic swappable back-end for XML parsing
 test_files: 
 - spec/multi_xml_spec.rb
 - spec/spec_helper.rb