nori 2.4.0 → 2.5.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 5734d4c7a672d830ea4199339b869da468bc2eab
+  data.tar.gz: d590616887899c0c17739e95b4f46e64ba12a367
+SHA512:
+  metadata.gz: ce4642320270373612e945d7912269e45541954ca9b1f163c81e9527333994aa6f1c2f289d11fc61c3768aea76dffcd3d64923f830e2439e995c2d305a6140e5
+  data.tar.gz: 0f3b03f4ffda5f874fd5a5780de08bbb891167351ea67c69d2f8b86f49e0a65f8b11582e0070343731398641afda5ae9b881f6ea308556f9ff1bdb98af3576b6

data/.travis.yml

@@ -5,5 +5,7 @@ rvm:
   - 1.9.2
   - 1.9.3
   - 2.0
+  - 2.1
+  - 2.2
   - jruby-19mode
-  - rbx
+  - rbx-2

data/CHANGELOG.md

@@ -1,3 +1,7 @@
+# 2.5.0 (2015-03-31)
+
+* Formally drop support for ruby 1.8.7. Installing Nori from rubygems for that version should no longer attempt to install versions that will not work.
+
 # 2.4.0 (2014-04-19)
 
 * Change: Dropped support for ruby 1.8, rubinius and ree

data/lib/nori/core_ext/hash.rb

@@ -4,21 +4,6 @@ class Nori
   module CoreExt
     module Hash
 
-      # @return <String> This hash as a query string
-      #
-      # @example
-      #   { :name => "Bob",
-      #     :address => {
-      #       :street => '111 Ruby Ave.',
-      #       :city => 'Ruby Central',
-      #       :phones => ['111-111-1111', '222-222-2222']
-      #     }
-      #   }.to_params
-      #     #=> "name=Bob&address[city]=Ruby Central&address[phones][]=111-111-1111&address[phones][]=222-222-2222&address[street]=111 Ruby Ave."
-      def to_params
-        map { |k, v| normalize_param(k,v) }.flatten.join('&')
-      end
-
       # @param key<Object> The key for the param.
       # @param value<Object> The value for the param.
       #

data/lib/nori/parser/nokogiri.rb

@@ -19,15 +19,27 @@ class Nori
           stack.push Nori::XMLUtilityNode.new(options, name, Hash[*attrs.flatten])
         end
 
+        # To keep backward behaviour compatibility
+        # delete last child if it is a space-only text node
         def end_element(name)
           if stack.size > 1
             last = stack.pop
+            maybe_string = last.children.last
+            if maybe_string.is_a?(String) and maybe_string.strip.empty?
+              last.children.pop
+            end
             stack.last.add_node last
           end
         end
 
+        # If this node is a successive character then add it as is.
+        # First child being a space-only text node will not be added
+        # because there is no previous characters.
         def characters(string)
-          stack.last.add_node(string) unless string.strip.length == 0 || stack.empty?
+          last = stack.last
+          if last and last.children.last.is_a?(String) or string.strip.size > 0
+            last.add_node(string)
+          end
         end
 
         alias cdata_block characters

data/lib/nori/version.rb

@@ -1,3 +1,3 @@
 class Nori
-  VERSION = "2.4.0"
+  VERSION = '2.5.0'
 end

data/lib/nori/xml_utility_node.rb

@@ -24,10 +24,11 @@ class Nori
     # 13:20:00-05:00    1:20 PM, US Eastern Standard Time
     # 13:20:00+02:00    1:20 PM, Central European Standard Time
     # 13:20:00Z         1:20 PM, Coordinated Universal Time (UTC)
+    # 13:20:30.5555Z    1:20 PM and 30.5555 seconds, Coordinated Universal Time (UTC)
     # 00:00:00          midnight
     # 24:00:00          midnight
 
-    XS_TIME = /^\d{2}:\d{2}:\d{2}[Z\.\-\+]?\d*:?\d*$/
+    XS_TIME = /^\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:?\d{2})?$/
 
     # Simple xs:date Regexp.
     # Valid xs:date formats
@@ -38,7 +39,7 @@ class Nori
     # 2004-04-12+02:00     April 12, 2004, Central European Summer Time, which is 2 hours ahead of Coordinated Universal Time (UTC)
     # 2004-04-12Z          April 12, 2004, Coordinated Universal Time (UTC)
 
-    XS_DATE = /^[-]?\d{4}-\d{2}-\d{2}[Z\-\+]?\d*:?\d*$/
+    XS_DATE = /^-?\d{4}-\d{2}-\d{2}(?:Z|[+-]\d{2}:?\d{2})?$/
 
     # Simple xs:dateTime Regexp.
     # Valid xs:dateTime formats
@@ -48,8 +49,9 @@ class Nori
     # 2004-04-12T13:20:00+02:00     1:20 pm on April 12, 2004, Central European Summer Time
     # 2004-04-12T13:20:15.5-05:00   1:20 pm and 15.5 seconds on April 12, 2004, US Eastern Standard Time
     # 2004-04-12T13:20:00Z          1:20 pm on April 12, 2004, Coordinated Universal Time (UTC)
+    # 2004-04-12T13:20:15.5Z        1:20 pm and 15.5 seconds on April 12, 2004, Coordinated Universal Time (UTC)
 
-    XS_DATE_TIME = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}[\.Z]?\d*[\-\+]?\d*:?\d*$/
+    XS_DATE_TIME = /^-?\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:?\d{2})?$/
 
     def self.typecasts
       @@typecasts

data/nori.gemspec

@@ -10,6 +10,7 @@ Gem::Specification.new do |s|
   s.homepage    = "https://github.com/savonrb/nori"
   s.summary     = "XML to Hash translator"
   s.description = s.summary
+  s.required_ruby_version = '>= 1.9.2'
 
   s.rubyforge_project = "nori"
   s.license = "MIT"

data/spec/nori/api_spec.rb

@@ -4,7 +4,7 @@ describe Nori do
 
   describe "PARSERS" do
     it "should return a Hash of parser details" do
-      Nori::PARSERS.should == { :rexml => "REXML", :nokogiri => "Nokogiri" }
+      expect(Nori::PARSERS).to eq({ :rexml => "REXML", :nokogiri => "Nokogiri" })
     end
   end
 
@@ -16,12 +16,12 @@ describe Nori do
         </history>
       XML
 
-      nori.parse(xml)["history"]["ns10:case"].should == "a_case"
+      expect(nori.parse(xml)["history"]["ns10:case"]).to eq("a_case")
     end
 
     it "defaults to not change XML tags" do
       xml = '<userResponse id="1"><accountStatus>active</accountStatus></userResponse>'
-      nori.parse(xml).should == { "userResponse" => { "@id" => "1", "accountStatus" => "active" } }
+      expect(nori.parse(xml)).to eq({ "userResponse" => { "@id" => "1", "accountStatus" => "active" } })
     end
 
     it "raises when passed unknown global options" do
@@ -33,7 +33,7 @@ describe Nori do
   context ".new with :strip_namespaces" do
     it "strips the namespace identifiers when set to true" do
       xml = '<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/"></soap:Envelope>'
-      nori(:strip_namespaces => true).parse(xml).should have_key("Envelope")
+      expect(nori(:strip_namespaces => true).parse(xml)).to have_key("Envelope")
     end
 
     it "still converts namespaced entries to array elements" do
@@ -47,7 +47,7 @@ describe Nori do
       XML
 
       expected = [{ "name" => "a_name" }, { "name" => "another_name" }]
-      nori(:strip_namespaces => true).parse(xml)["history"]["case"].should == expected
+      expect(nori(:strip_namespaces => true).parse(xml)["history"]["case"]).to eq(expected)
     end
   end
 
@@ -58,7 +58,7 @@ describe Nori do
       snakecase_symbols = lambda { |tag| tag.snakecase.to_sym }
       nori = nori(:convert_tags_to => snakecase_symbols)
 
-      nori.parse(xml).should == { :user_response => { :@id => "1", :account_status => "active" } }
+      expect(nori.parse(xml)).to eq({ :user_response => { :@id => "1", :account_status => "active" } })
     end
   end
 
@@ -98,29 +98,29 @@ describe Nori do
   context "#parse" do
     it "defaults to use advanced typecasting" do
       hash = nori.parse("<value>true</value>")
-      hash["value"].should == true
+      expect(hash["value"]).to eq(true)
     end
 
     it "defaults to use the Nokogiri parser" do
       # parsers are loaded lazily by default
       require "nori/parser/nokogiri"
 
-      Nori::Parser::Nokogiri.should_receive(:parse).and_return({})
+      expect(Nori::Parser::Nokogiri).to receive(:parse).and_return({})
       nori.parse("<any>thing</any>")
     end
 
     it "strips the XML" do
       xml = double("xml")
-      xml.should_receive(:strip).and_return("<any>thing</any>")
+      expect(xml).to receive(:strip).and_return("<any>thing</any>")
 
-      nori.parse(xml).should == { "any" => "thing" }
+      expect(nori.parse(xml)).to eq({ "any" => "thing" })
     end
   end
 
   context "#parse without :advanced_typecasting" do
     it "can be changed to not typecast too much" do
       hash = nori(:advanced_typecasting => false).parse("<value>true</value>")
-      hash["value"].should == "true"
+      expect(hash["value"]).to eq("true")
     end
   end
 
@@ -129,7 +129,7 @@ describe Nori do
       # parsers are loaded lazily by default
       require "nori/parser/rexml"
 
-      Nori::Parser::REXML.should_receive(:parse).and_return({})
+      expect(Nori::Parser::REXML).to receive(:parse).and_return({})
       nori(:parser => :rexml).parse("<any>thing</any>")
     end
   end
@@ -138,13 +138,13 @@ describe Nori do
     it "can be changed to not delete xmlns attributes" do
       xml = '<userResponse xmlns="http://schema.company.com/some/path/to/namespace/v1"><accountStatus>active</accountStatus></userResponse>'
       hash = nori(:delete_namespace_attributes => false).parse(xml)
-      hash.should == {"userResponse" => {"@xmlns" => "http://schema.company.com/some/path/to/namespace/v1", "accountStatus" => "active"}}
+      expect(hash).to eq({"userResponse" => {"@xmlns" => "http://schema.company.com/some/path/to/namespace/v1", "accountStatus" => "active"}})
     end
 
     it "can be changed to not delete xsi attributes" do
       xml = '<userResponse xsi="abc:myType"><accountStatus>active</accountStatus></userResponse>'
       hash = nori(:delete_namespace_attributes => false).parse(xml)
-      hash.should == {"userResponse" => {"@xsi" => "abc:myType", "accountStatus" => "active"}}
+      expect(hash).to eq({"userResponse" => {"@xsi" => "abc:myType", "accountStatus" => "active"}})
     end
   end
 
@@ -152,13 +152,13 @@ describe Nori do
     it "can be changed to delete xmlns attributes" do
       xml = '<userResponse xmlns="http://schema.company.com/some/path/to/namespace/v1"><accountStatus>active</accountStatus></userResponse>'
       hash = nori(:delete_namespace_attributes => true).parse(xml)
-      hash.should == {"userResponse" => {"accountStatus" => "active"}}
+      expect(hash).to eq({"userResponse" => {"accountStatus" => "active"}})
     end
 
     it "can be changed to delete xsi attributes" do
       xml = '<userResponse xsi="abc:myType"><accountStatus>active</accountStatus></userResponse>'
       hash = nori(:delete_namespace_attributes => true).parse(xml)
-      hash.should == {"userResponse" => {"accountStatus" => "active"}}
+      expect(hash).to eq({"userResponse" => {"accountStatus" => "active"}})
     end
   end
 
@@ -166,7 +166,7 @@ describe Nori do
     it "can be configured to skip dash to underscope conversion" do
       xml = '<any-tag>foo bar</any-tag'
       hash = nori(:convert_dashes_to_underscores => false).parse(xml)
-      hash.should == {'any-tag' => 'foo bar'}
+      expect(hash).to eq({'any-tag' => 'foo bar'})
     end
   end
 

data/spec/nori/core_ext/hash_spec.rb

@@ -2,36 +2,6 @@ require "spec_helper"
 
 describe Hash do
 
-  describe "#to_params" do
-
-    {
-      { "foo" => "bar", "baz" => "bat" } => "foo=bar&baz=bat",
-      { "foo" => [ "bar", "baz" ] } => "foo[]=bar&foo[]=baz",
-      { "foo" => [ {"bar" => "1"}, {"bar" => 2} ] } => "foo[][bar]=1&foo[][bar]=2",
-      { "foo" => { "bar" => [ {"baz" => 1}, {"baz" => "2"}  ] } } => "foo[bar][][baz]=1&foo[bar][][baz]=2",
-      { "foo" => {"1" => "bar", "2" => "baz"} } => "foo[1]=bar&foo[2]=baz"
-    }.each do |hash, params|
-      it "should covert hash: #{hash.inspect} to params: #{params.inspect}" do
-        hash.to_params.split('&').sort.should == params.split('&').sort
-      end
-    end
-
-    it "should not leave a trailing &" do
-      {
-        :name => 'Bob',
-        :address => {
-          :street => '111 Ruby Ave.',
-          :city => 'Ruby Central',
-          :phones => ['111-111-1111', '222-222-2222']
-        }
-      }.to_params.should_not =~ /&$/
-    end
-
-    it "should URL encode unsafe characters" do
-      {:q => "?&\" +"}.to_params.should == "q=%3F%26%22%20%2B"
-    end
-  end
-
   describe "#normalize_param" do
     it "should have specs"
   end
@@ -40,8 +10,8 @@ describe Hash do
 
     it "should turn the hash into xml attributes" do
       attrs = { :one => "ONE", "two" => "TWO" }.to_xml_attributes
-      attrs.should =~ /one="ONE"/m
-      attrs.should =~ /two="TWO"/m
+      expect(attrs).to match(/one="ONE"/m)
+      expect(attrs).to match(/two="TWO"/m)
     end
 
     it "should preserve _ in hash keys" do
@@ -51,9 +21,9 @@ describe Hash do
         :merb                => "uses extlib"
       }.to_xml_attributes
 
-      attrs.should =~ /some_long_attribute="with short value"/
-      attrs.should =~ /merb="uses extlib"/
-      attrs.should =~ /crash="burn"/
+      expect(attrs).to match(/some_long_attribute="with short value"/)
+      expect(attrs).to match(/merb="uses extlib"/)
+      expect(attrs).to match(/crash="burn"/)
     end
   end
 

data/spec/nori/core_ext/object_spec.rb

@@ -5,13 +5,13 @@ describe Object do
   describe "#blank?" do
     [nil, false, [], {}].each do |object|
       it "should return true for: #{object.inspect}" do
-        object.blank?.should be_true
+        expect(object.blank?).to be_true
       end
     end
 
     [true, [nil], 1, "string", { :key => "value" }].each do |object|
       it "should return false for: #{object.inspect}" do
-        object.blank?.should be_false
+        expect(object.blank?).to be_false
       end
     end
   end

data/spec/nori/core_ext/string_spec.rb

@@ -4,29 +4,29 @@ describe String do
 
   describe "#snakecase" do
     it "lowercases one word CamelCase" do
-      "Merb".snakecase.should == "merb"
+      expect("Merb".snakecase).to eq("merb")
     end
 
     it "makes one underscore snakecase two word CamelCase" do
-      "MerbCore".snakecase.should == "merb_core"
+      expect("MerbCore".snakecase).to eq("merb_core")
     end
 
     it "handles CamelCase with more than 2 words" do
-      "SoYouWantContributeToMerbCore".snakecase.should == "so_you_want_contribute_to_merb_core"
+      expect("SoYouWantContributeToMerbCore".snakecase).to eq("so_you_want_contribute_to_merb_core")
     end
 
     it "handles CamelCase with more than 2 capital letter in a row" do
-      "CNN".snakecase.should == "cnn"
-      "CNNNews".snakecase.should == "cnn_news"
-      "HeadlineCNNNews".snakecase.should == "headline_cnn_news"
+      expect("CNN".snakecase).to eq("cnn")
+      expect("CNNNews".snakecase).to eq("cnn_news")
+      expect("HeadlineCNNNews".snakecase).to eq("headline_cnn_news")
     end
 
     it "does NOT change one word lowercase" do
-      "merb".snakecase.should == "merb"
+      expect("merb".snakecase).to eq("merb")
     end
 
     it "leaves snake_case as is" do
-      "merb_core".snakecase.should == "merb_core"
+      expect("merb_core".snakecase).to eq("merb_core")
     end
   end
 

data/spec/nori/nori_spec.rb

@@ -9,12 +9,12 @@ describe Nori do
 
       it "should work with unnormalized characters" do
         xml = '<root>&amp;</root>'
-        parse(xml).should == { 'root' => "&" }
+        expect(parse(xml)).to eq({ 'root' => "&" })
       end
 
       it "should transform a simple tag with content" do
         xml = "<tag>This is the contents</tag>"
-        parse(xml).should == { 'tag' => 'This is the contents' }
+        expect(parse(xml)).to eq({ 'tag' => 'This is the contents' })
       end
 
       it "should work with cdata tags" do
@@ -25,13 +25,13 @@ describe Nori do
           ]]>
           </tag>
         END
-        parse(xml)["tag"].strip.should == "text inside cdata"
+        expect(parse(xml)["tag"].strip).to eq("text inside cdata")
       end
 
       it "should transform a simple tag with attributes" do
         xml = "<tag attr1='1' attr2='2'></tag>"
         hash = { 'tag' => { '@attr1' => '1', '@attr2' => '2' } }
-        parse(xml).should == hash
+        expect(parse(xml)).to eq(hash)
       end
 
       it "should transform repeating siblings into an array" do
@@ -42,7 +42,7 @@ describe Nori do
           </opt>
         XML
 
-        parse(xml)['opt']['user'].class.should == Array
+        expect(parse(xml)['opt']['user'].class).to eq(Array)
 
         hash = {
           'opt' => {
@@ -56,7 +56,7 @@ describe Nori do
           }
         }
 
-        parse(xml).should == hash
+        expect(parse(xml)).to eq(hash)
       end
 
       it "should not transform non-repeating siblings into an array" do
@@ -66,7 +66,7 @@ describe Nori do
           </opt>
         XML
 
-        parse(xml)['opt']['user'].class.should == Hash
+        expect(parse(xml)['opt']['user'].class).to eq(Hash)
 
         hash = {
           'opt' => {
@@ -77,7 +77,7 @@ describe Nori do
           }
         }
 
-        parse(xml).should == hash
+        expect(parse(xml)).to eq(hash)
       end
 
       it "should prefix attributes with an @-sign to avoid problems with overwritten values" do
@@ -88,96 +88,101 @@ describe Nori do
           </multiRef>
         XML
 
-        parse(xml)["multiRef"].should == { "login" => "grep", "@id" => "id1", "id" => "76737" }
+        expect(parse(xml)["multiRef"]).to eq({ "login" => "grep", "@id" => "id1", "id" => "76737" })
       end
 
       context "without advanced typecasting" do
         it "should not transform 'true'" do
           hash = parse("<value>true</value>", :advanced_typecasting => false)
-          hash["value"].should == "true"
+          expect(hash["value"]).to eq("true")
         end
 
         it "should not transform 'false'" do
           hash = parse("<value>false</value>", :advanced_typecasting => false)
-          hash["value"].should == "false"
+          expect(hash["value"]).to eq("false")
         end
 
         it "should not transform Strings matching the xs:time format" do
           hash = parse("<value>09:33:55Z</value>", :advanced_typecasting => false)
-          hash["value"].should == "09:33:55Z"
+          expect(hash["value"]).to eq("09:33:55Z")
         end
 
         it "should not transform Strings matching the xs:date format" do
           hash = parse("<value>1955-04-18-05:00</value>", :advanced_typecasting => false)
-          hash["value"].should == "1955-04-18-05:00"
+          expect(hash["value"]).to eq("1955-04-18-05:00")
         end
 
         it "should not transform Strings matching the xs:dateTime format" do
           hash = parse("<value>1955-04-18T11:22:33-05:00</value>", :advanced_typecasting => false)
-          hash["value"].should == "1955-04-18T11:22:33-05:00"
+          expect(hash["value"]).to eq("1955-04-18T11:22:33-05:00")
         end
       end
 
       context "with advanced typecasting" do
         it "should transform 'true' to TrueClass" do
-          parse("<value>true</value>")["value"].should == true
+          expect(parse("<value>true</value>")["value"]).to eq(true)
         end
 
         it "should transform 'false' to FalseClass" do
-          parse("<value>false</value>")["value"].should == false
+          expect(parse("<value>false</value>")["value"]).to eq(false)
         end
 
         it "should transform Strings matching the xs:time format to Time objects" do
-          parse("<value>09:33:55Z</value>")["value"].should == Time.parse("09:33:55Z")
+          expect(parse("<value>09:33:55.7Z</value>")["value"]).to eq(Time.parse("09:33:55.7Z"))
         end
 
         it "should transform Strings matching the xs:time format ahead of utc to Time objects" do
-          parse("<value>09:33:55+02:00</value>")["value"].should == Time.parse("09:33:55+02:00")
+          expect(parse("<value>09:33:55+02:00</value>")["value"]).to eq(Time.parse("09:33:55+02:00"))
         end
 
         it "should transform Strings matching the xs:date format to Date objects" do
-          parse("<value>1955-04-18-05:00</value>")["value"].should == Date.parse("1955-04-18-05:00")
+          expect(parse("<value>1955-04-18-05:00</value>")["value"]).to eq(Date.parse("1955-04-18-05:00"))
         end
 
         it "should transform Strings matching the xs:dateTime format ahead of utc to Date objects" do
-          parse("<value>1955-04-18+02:00</value>")["value"].should == Date.parse("1955-04-18+02:00")
+          expect(parse("<value>1955-04-18+02:00</value>")["value"]).to eq(Date.parse("1955-04-18+02:00"))
         end
 
         it "should transform Strings matching the xs:dateTime format to DateTime objects" do
-          parse("<value>1955-04-18T11:22:33-05:00</value>")["value"].should ==
-            DateTime.parse("1955-04-18T11:22:33-05:00")
+          expect(parse("<value>1955-04-18T11:22:33.5Z</value>")["value"]).to eq(
+            DateTime.parse("1955-04-18T11:22:33.5Z")
+          )
         end
 
         it "should transform Strings matching the xs:dateTime format ahead of utc to DateTime objects" do
-          parse("<value>1955-04-18T11:22:33+02:00</value>")["value"].should ==
+          expect(parse("<value>1955-04-18T11:22:33+02:00</value>")["value"]).to eq(
             DateTime.parse("1955-04-18T11:22:33+02:00")
+          )
         end
 
         it "should transform Strings matching the xs:dateTime format with seconds and an offset to DateTime objects" do
-          parse("<value>2004-04-12T13:20:15.5-05:00</value>")["value"].should ==
+          expect(parse("<value>2004-04-12T13:20:15.5-05:00</value>")["value"]).to eq(
             DateTime.parse("2004-04-12T13:20:15.5-05:00")
+          )
         end
 
         it "should not transform Strings containing an xs:time String and more" do
-          parse("<value>09:33:55Z is a time</value>")["value"].should == "09:33:55Z is a time"
-          parse("<value>09:33:55Z_is_a_file_name</value>")["value"].should == "09:33:55Z_is_a_file_name"
+          expect(parse("<value>09:33:55Z is a time</value>")["value"]).to eq("09:33:55Z is a time")
+          expect(parse("<value>09:33:55Z_is_a_file_name</value>")["value"]).to eq("09:33:55Z_is_a_file_name")
         end
 
         it "should not transform Strings containing an xs:date String and more" do
-          parse("<value>1955-04-18-05:00 is a date</value>")["value"].should == "1955-04-18-05:00 is a date"
-          parse("<value>1955-04-18-05:00_is_a_file_name</value>")["value"].should == "1955-04-18-05:00_is_a_file_name"
+          expect(parse("<value>1955-04-18-05:00 is a date</value>")["value"]).to eq("1955-04-18-05:00 is a date")
+          expect(parse("<value>1955-04-18-05:00_is_a_file_name</value>")["value"]).to eq("1955-04-18-05:00_is_a_file_name")
         end
 
         it "should not transform Strings containing an xs:dateTime String and more" do
-          parse("<value>1955-04-18T11:22:33-05:00 is a dateTime</value>")["value"].should ==
+          expect(parse("<value>1955-04-18T11:22:33-05:00 is a dateTime</value>")["value"]).to eq(
             "1955-04-18T11:22:33-05:00 is a dateTime"
-          parse("<value>1955-04-18T11:22:33-05:00_is_a_file_name</value>")["value"].should ==
+          )
+          expect(parse("<value>1955-04-18T11:22:33-05:00_is_a_file_name</value>")["value"]).to eq(
             "1955-04-18T11:22:33-05:00_is_a_file_name"
+          )
         end
 
         ["00-00-00", "0000-00-00", "0000-00-00T00:00:00", "0569-23-0141", "DS2001-19-1312654773", "e6:53:01:00:ce:b4:06"].each do |date_string|
           it "should not transform a String like '#{date_string}' to date or time" do
-            parse("<value>#{date_string}</value>")["value"].should == date_string
+            expect(parse("<value>#{date_string}</value>")["value"]).to eq(date_string)
           end
         end
       end
@@ -194,59 +199,59 @@ describe Nori do
         end
 
         it "correctly parse text nodes" do
-          @data.should == {
+          expect(@data).to eq({
             'opt' => {
               'user' => [
                 'Gary R Epstein',
                 'Simon T Tyson'
               ]
             }
-          }
+          })
         end
 
-        it "be parse attributes for text node if present" do
-          @data['opt']['user'][0].attributes.should == {'login' => 'grep'}
+        it "parses attributes for text node if present" do
+          expect(@data['opt']['user'][0].attributes).to eq({'login' => 'grep'})
         end
 
         it "default attributes to empty hash if not present" do
-          @data['opt']['user'][1].attributes.should == {}
+          expect(@data['opt']['user'][1].attributes).to eq({})
         end
 
         it "add 'attributes' accessor methods to parsed instances of String" do
-          @data['opt']['user'][0].should respond_to(:attributes)
-          @data['opt']['user'][0].should respond_to(:attributes=)
+          expect(@data['opt']['user'][0]).to respond_to(:attributes)
+          expect(@data['opt']['user'][0]).to respond_to(:attributes=)
         end
 
         it "not add 'attributes' accessor methods to all instances of String" do
-          "some-string".should_not respond_to(:attributes)
-          "some-string".should_not respond_to(:attributes=)
+          expect("some-string").not_to respond_to(:attributes)
+          expect("some-string").not_to respond_to(:attributes=)
         end
       end
 
       it "should typecast an integer" do
         xml = "<tag type='integer'>10</tag>"
-        parse(xml)['tag'].should == 10
+        expect(parse(xml)['tag']).to eq(10)
       end
 
       it "should typecast a true boolean" do
         xml = "<tag type='boolean'>true</tag>"
-        parse(xml)['tag'].should be(true)
+        expect(parse(xml)['tag']).to be(true)
       end
 
       it "should typecast a false boolean" do
         ["false"].each do |w|
-          parse("<tag type='boolean'>#{w}</tag>")['tag'].should be(false)
+          expect(parse("<tag type='boolean'>#{w}</tag>")['tag']).to be(false)
         end
       end
 
       it "should typecast a datetime" do
         xml = "<tag type='datetime'>2007-12-31 10:32</tag>"
-        parse(xml)['tag'].should == Time.parse( '2007-12-31 10:32' ).utc
+        expect(parse(xml)['tag']).to eq(Time.parse( '2007-12-31 10:32' ).utc)
       end
 
       it "should typecast a date" do
         xml = "<tag type='date'>2007-12-31</tag>"
-        parse(xml)['tag'].should == Date.parse('2007-12-31')
+        expect(parse(xml)['tag']).to eq(Date.parse('2007-12-31'))
       end
 
       xml_entities = {
@@ -260,51 +265,51 @@ describe Nori do
       it "should unescape html entities" do
         xml_entities.each do |k,v|
           xml = "<tag>Some content #{v}</tag>"
-          parse(xml)['tag'].should =~ Regexp.new(k)
+          expect(parse(xml)['tag']).to match(Regexp.new(k))
         end
       end
 
       it "should unescape XML entities in attributes" do
         xml_entities.each do |key, value|
           xml = "<tag attr='Some content #{value}'></tag>"
-          parse(xml)['tag']['@attr'].should =~ Regexp.new(key)
+          expect(parse(xml)['tag']['@attr']).to match(Regexp.new(key))
         end
       end
 
       it "should undasherize keys as tags" do
         xml = "<tag-1>Stuff</tag-1>"
-        parse(xml).keys.should include('tag_1')
+        expect(parse(xml).keys).to include('tag_1')
       end
 
       it "should undasherize keys as attributes" do
         xml = "<tag1 attr-1='1'></tag1>"
-        parse(xml)['tag1'].keys.should include('@attr_1')
+        expect(parse(xml)['tag1'].keys).to include('@attr_1')
       end
 
       it "should undasherize keys as tags and attributes" do
         xml = "<tag-1 attr-1='1'></tag-1>"
-        parse(xml).keys.should include('tag_1')
-        parse(xml)['tag_1'].keys.should include('@attr_1')
+        expect(parse(xml).keys).to include('tag_1')
+        expect(parse(xml)['tag_1'].keys).to include('@attr_1')
       end
 
       it "should render nested content correctly" do
         xml = "<root><tag1>Tag1 Content <em><strong>This is strong</strong></em></tag1></root>"
-        parse(xml)['root']['tag1'].should == "Tag1 Content <em><strong>This is strong</strong></em>"
+        expect(parse(xml)['root']['tag1']).to eq("Tag1 Content <em><strong>This is strong</strong></em>")
       end
 
-      it "should render nested content with splshould text nodes correctly" do
+      it "should render nested content with text nodes correctly" do
         xml = "<root>Tag1 Content<em>Stuff</em> Hi There</root>"
-        parse(xml)['root'].should == "Tag1 Content<em>Stuff</em> Hi There"
+        expect(parse(xml)['root']).to eq("Tag1 Content<em>Stuff</em> Hi There")
       end
 
       it "should ignore attributes when a child is a text node" do
         xml = "<root attr1='1'>Stuff</root>"
-        parse(xml).should == { "root" => "Stuff" }
+        expect(parse(xml)).to eq({ "root" => "Stuff" })
       end
 
       it "should ignore attributes when any child is a text node" do
         xml = "<root attr1='1'>Stuff <em>in italics</em></root>"
-        parse(xml).should == { "root" => "Stuff <em>in italics</em>" }
+        expect(parse(xml)).to eq({ "root" => "Stuff <em>in italics</em>" })
       end
 
       it "should correctly transform multiple children" do
@@ -329,7 +334,7 @@ describe Nori do
           }
         }
 
-        parse(xml).should == hash
+        expect(parse(xml)).to eq(hash)
       end
 
       it "should properly handle nil values (ActiveSupport Compatible)" do
@@ -359,7 +364,7 @@ describe Nori do
           'nil_true'   => nil,
           'namespaced' => nil
         }
-        parse(topic_xml)["topic"].should == expected_topic_hash
+        expect(parse(topic_xml)["topic"]).to eq(expected_topic_hash)
       end
 
       it "should handle a single record from xml (ActiveSupport Compatible)" do
@@ -404,7 +409,7 @@ describe Nori do
         }
 
         parse(topic_xml)["topic"].each do |k,v|
-          v.should == expected_topic_hash[k]
+          expect(v).to eq(expected_topic_hash[k])
         end
       end
 
@@ -456,7 +461,7 @@ describe Nori do
 
         # puts Nori.parse(topics_xml)['topics'].first.inspect
         parse(topics_xml)["topics"].first.each do |k,v|
-          v.should == expected_topic_hash[k]
+          expect(v).to eq(expected_topic_hash[k])
         end
       end
 
@@ -467,7 +472,7 @@ describe Nori do
             <user name="value"><age>21</age></user>
           XML
 
-          parse(xml, :convert_attributes_to => converter).should == {'user' => {'@name_k' => 'value_v', 'age' => '21'}}
+          expect(parse(xml, :convert_attributes_to => converter)).to eq({'user' => {'@name_k' => 'value_v', 'age' => '21'}})
         end
       end
 
@@ -492,7 +497,7 @@ describe Nori do
         }
 
         parse(topic_xml)["rsp"]["photos"]["photo"].each do |k, v|
-          v.should == expected_topic_hash[k]
+          expect(v).to eq(expected_topic_hash[k])
         end
       end
 
@@ -503,7 +508,7 @@ describe Nori do
           </blog>
         XML
         expected_blog_hash = {"blog" => {"posts" => []}}
-        parse(blog_xml).should == expected_blog_hash
+        expect(parse(blog_xml)).to eq(expected_blog_hash)
       end
 
       it "should handle empty array with whitespace from xml (ActiveSupport Compatible)" do
@@ -514,7 +519,7 @@ describe Nori do
           </blog>
         XML
         expected_blog_hash = {"blog" => {"posts" => []}}
-        parse(blog_xml).should == expected_blog_hash
+        expect(parse(blog_xml)).to eq(expected_blog_hash)
       end
 
       it "should handle array with one entry from_xml (ActiveSupport Compatible)" do
@@ -526,7 +531,7 @@ describe Nori do
           </blog>
         XML
         expected_blog_hash = {"blog" => {"posts" => ["a post"]}}
-        parse(blog_xml).should == expected_blog_hash
+        expect(parse(blog_xml)).to eq(expected_blog_hash)
       end
 
       it "should handle array with multiple entries from xml (ActiveSupport Compatible)" do
@@ -539,7 +544,7 @@ describe Nori do
           </blog>
         XML
         expected_blog_hash = {"blog" => {"posts" => ["a post", "another post"]}}
-        parse(blog_xml).should == expected_blog_hash
+        expect(parse(blog_xml)).to eq(expected_blog_hash)
       end
 
       it "should handle file types (ActiveSupport Compatible)" do
@@ -550,12 +555,12 @@ describe Nori do
           </blog>
         XML
         hash = parse(blog_xml)
-        hash.keys.should include('blog')
-        hash['blog'].keys.should include('logo')
+        expect(hash.keys).to include('blog')
+        expect(hash['blog'].keys).to include('logo')
 
         file = hash['blog']['logo']
-        file.original_filename.should == 'logo.png'
-        file.content_type.should == 'image/png'
+        expect(file.original_filename).to eq('logo.png')
+        expect(file.content_type).to eq('image/png')
       end
 
       it "should handle file from xml with defaults (ActiveSupport Compatible)" do
@@ -566,8 +571,8 @@ describe Nori do
           </blog>
         XML
         file = parse(blog_xml)['blog']['logo']
-        file.original_filename.should == 'untitled'
-        file.content_type.should == 'application/octet-stream'
+        expect(file.original_filename).to eq('untitled')
+        expect(file.content_type).to eq('application/octet-stream')
       end
 
       it "should handle xsd like types from xml (ActiveSupport Compatible)" do
@@ -591,7 +596,7 @@ describe Nori do
           'illustration' => "babe.png"
         }
 
-        parse(bacon_xml)["bacon"].should == expected_bacon_hash
+        expect(parse(bacon_xml)["bacon"]).to eq(expected_bacon_hash)
       end
 
       it "should let type trickle through when unknown (ActiveSupport Compatible)" do
@@ -608,7 +613,7 @@ describe Nori do
           'image' => {'@type' => 'ProductImage', 'filename' => 'image.gif' },
         }
 
-        parse(product_xml)["product"].should == expected_product_hash
+        expect(parse(product_xml)["product"]).to eq(expected_product_hash)
       end
 
       it "should handle unescaping from xml (ActiveResource Compatible)" do
@@ -618,16 +623,16 @@ describe Nori do
          'pre_escaped_string' => 'First &amp; Last Name'
        }
 
-       parse(xml_string)['person'].should == expected_hash
+       expect(parse(xml_string)['person']).to eq(expected_hash)
      end
 
       it "handle an empty xml string" do
-        parse('').should == {}
+        expect(parse('')).to eq({})
       end
 
       # As returned in the response body by the unfuddle XML API when creating objects
       it "handle an xml string containing a single space" do
-        parse(' ').should == {}
+        expect(parse(' ')).to eq({})
       end
 
     end

metadata

@@ -1,8 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: nori
 version: !ruby/object:Gem::Version
-  version: 2.4.0
-  prerelease: 
+  version: 2.5.0
 platform: ruby
 authors:
 - Daniel Harrington
@@ -11,54 +10,48 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-04-19 00:00:00.000000000 Z
+date: 2015-04-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '10.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '10.0'
 - !ruby/object:Gem::Dependency
   name: nokogiri
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: 1.4.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: 1.4.0
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '2.12'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '2.12'
 description: XML to Hash translator
@@ -67,9 +60,9 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
-- .rspec
-- .travis.yml
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
 - CHANGELOG.md
 - Gemfile
 - LICENSE
@@ -98,27 +91,26 @@ files:
 homepage: https://github.com/savonrb/nori
 licenses:
 - MIT
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.9.2
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: nori
-rubygems_version: 1.8.23
+rubygems_version: 2.2.2
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: XML to Hash translator
 test_files:
 - spec/nori/api_spec.rb