roxml 3.2.2 → 4.1.1

data/spec/shared_specs.rb

@@ -2,13 +2,13 @@ if defined?(shared_examples_for)
   shared_examples_for "freezable xml reference" do
     describe "with :frozen option" do
       it "should be frozen" do
-        @frozen.frozen?.should be_true
+        expect(@frozen.frozen?).to be_truthy
       end
     end
 
     describe "without :frozen option" do
       it "should not be frozen" do
-        @unfrozen.frozen?.should be_false
+        expect(@unfrozen.frozen?).to be_falsey
       end
     end
   end

data/spec/spec_helper.rb

@@ -2,6 +2,8 @@ require 'ostruct'
 require 'rubygems'
 require 'pathname'
 require 'ostruct'
+require 'rspec/matchers' # req by equivalent-xml custom matcher `be_equivalent_to`
+require 'equivalent-xml'
 
 require_relative './../test/support/fixtures'
 require_relative './../lib/roxml'

data/spec/xml/array_spec.rb

@@ -22,7 +22,7 @@ end
 describe ":as => []" do
   context "with plural from" do
     it "should accept the plural name as the name for each item" do
-      ArraySpec::MyXml.from_xml(%(
+      expect(ArraySpec::MyXml.from_xml(%(
       <myxml>
         <store>
           <books><id>1</id><title>first book</title></books>
@@ -30,7 +30,7 @@ describe ":as => []" do
           <books><id>3</id><title>third book</title></books>
         </store>
       </myxml>
-      )).store.books.size.should == 3
+      )).store.books.size).to eq(3)
     end
   end
 end

data/spec/xml/attributes_spec.rb

@@ -16,7 +16,7 @@ describe ROXML::XMLAttributeRef do
     end
 
     it "should return one instance" do
-      @ref.value_in(@xml).should == "first"
+      expect(@ref.value_in(@xml)).to eq("first")
     end
     it "should output one instance"
   end
@@ -27,13 +27,13 @@ describe ROXML::XMLAttributeRef do
     end
 
     it "should collect all instances" do
-      @ref.value_in(@xml).should == ["first", "second", "third"]
+      expect(@ref.value_in(@xml)).to eq(["first", "second", "third"])
     end
 
     it "should output all instances" do
       xml = ROXML::XML.new_node('myxml')
       @ref.update_xml(xml, ["first", "second", "third"])
-      xml.to_s.squeeze(' ').should == @xml.root.to_s.squeeze(' ')
+      expect(xml.to_s.squeeze(' ')).to eq(@xml.root.to_s.squeeze(' '))
     end
   end
   
@@ -56,15 +56,15 @@ describe ROXML::XMLAttributeRef do
       end
 
       it "should collect all instances" do
-        pending "Test bug?"
-        @ref.value_in(@xml).should == ["first", "second", "third"]
+        skip "Test bug?"
+        expect(@ref.value_in(@xml)).to eq(["first", "second", "third"])
       end
 
       it "should output all instances with namespaces" do
-        pending "Full namespace write support"
+        skip "Full namespace write support"
         xml = ROXML::XML.new_node('result')
         @ref.update_xml(xml, ["first", "second", "third"])
-        xml.should == @xml.root
+        expect(xml).to eq(@xml.root)
       end
     end
   end

data/spec/xml/encoding_spec.rb

@@ -13,41 +13,41 @@ describe ROXML, "encoding" do
       res.message = "sadfk одловыа jjklsd " #random russian  and english charecters
       doc = ROXML::XML::Document.new
       doc.root = res.to_xml
-      if defined?(Nokogiri)
+      expect(if defined?(Nokogiri)
         doc.at('message').inner_text
       else
         doc.find_first('message').inner_xml
-      end.should == "sadfk одловыа jjklsd "
+      end).to eq("sadfk одловыа jjklsd ")
     end
   
     it "should output those characters as input via xml" do
       res = TestResult.from_xml("<test_result><message>sadfk одловыа jjklsd </message></test_result>")
       doc = ROXML::XML::Document.new
       doc.root = res.to_xml
-      if defined?(Nokogiri)
+      expect(if defined?(Nokogiri)
         doc.at('message').inner_text
       else
         doc.find_first('message').inner_xml
-      end.should == "sadfk одловыа jjklsd "
+      end).to eq("sadfk одловыа jjklsd ")
     end
   
     it "should allow override via the document" do
       res = TestResult.from_xml("<test_result><message>sadfk одловыа jjklsd </message></test_result>")
-      if defined?(Nokogiri)
+      expect(if defined?(Nokogiri)
         xml = res.to_xml
         doc = xml.document
         doc.root = xml
         doc.encoding = 'ISO-8859-1'
-        doc.to_s.should include('ISO-8859-1')
+        expect(doc.to_s).to include('ISO-8859-1')
         doc.at('message').inner_text
       else
         doc = LibXML::XML::Document.new
         doc.encoding = LibXML::XML::Encoding::ASCII
         doc.root = res.to_xml
-        pending "Libxml bug"
-        doc.to_s.should include('ISO-8859-1')
+        skip "Libxml bug"
+        expect(doc.to_s).to include('ISO-8859-1')
         doc.find_first('message').inner_xml
-      end.should == "sadfk одловыа jjklsd "
+      end).to eq("sadfk одловыа jjklsd ")
     end
   end
 end

data/spec/xml/namespace_spec.rb

@@ -28,7 +28,7 @@ EOS
 
       xml_name 'NetworkConfig'
       xml_reader    :name, :from => '@name'
-      xml_reader    :errors, :as => []
+      xml_reader    :errors, :as => [], :from => 'gronk:error'
       xml_accessor  :fence_mode, :from => 'vmw:FenceMode'
       xml_accessor  :dhcp?, :from => 'vmw:Dhcp'
     end
@@ -50,9 +50,8 @@ EOS
     describe "#to_xml" do
       it "should reproduce the input xml" do
         output = ROXML::XML::Document.new
-        output.root = VApp.from_xml(@xml).to_xml
-        pending "Full namespace write support"
-        output.should == ROXML::XML.parse_string(@xml)
+        output.root = VApp.from_xml(@xml).to_xml(:namespaces => {'vmw' => "http://foo.example.com", 'gronk' => "http://gronk.example.com"})
+        expect(ROXML::XML.parse_string(output.to_s)).to be_equivalent_to(ROXML::XML.parse_string(@xml))
       end
     end
   end
@@ -61,23 +60,23 @@ EOS
     context "with a namespacey :from" do
       context "and an explicit :namespace" do
         it "should raise" do
-          proc do
+          expect do
             Class.new do
               include ROXML
               xml_reader :default_namespace_with_namespacey_from_and_explicit_namespace, :from => 'namespacey:with_namespacey_from', :namespace => 'explicit'
             end
-          end.should raise_error(ROXML::ContradictoryNamespaces)
+          end.to raise_error(ROXML::ContradictoryNamespaces)
         end
       end
 
       context "and :namespace => false" do
         it "should raise" do
-          proc do
+          expect do
             Class.new do
               include ROXML
               xml_reader :default_namespace_with_namespacey_from_and_namespace_false, :from => 'namespacey:with_namespacey_from', :namespace => false
             end
-          end.should raise_error(ROXML::ContradictoryNamespaces)
+          end.to raise_error(ROXML::ContradictoryNamespaces)
         end
       end
     end
@@ -87,12 +86,12 @@ EOS
     it_should_behave_like "roxml namespacey declaration"
     
     it "should use the default namespace" do
-      @instance.default_namespace.should == 'default namespace node'
+      expect(@instance.default_namespace).to eq('default namespace node')
     end
     
     context "and :namespace => false" do
       it "should find the namespace-less node" do
-        @instance.default_namespace_with_namespace_false.should == 'namespaceless node'
+        expect(@instance.default_namespace_with_namespace_false).to eq('namespaceless node')
       end
     end
 
@@ -104,25 +103,37 @@ EOS
 
     context "with a namespace-less :from" do
       it "should use the default namespace" do
-        @instance.default_namespace_with_namespaceless_from.should == 'default namespace node'
+        expect(@instance.default_namespace_with_namespaceless_from).to eq('default namespace node')
       end
       
       context "and :namespace => false" do
         it "should find the namespace-less node" do
-          @instance.default_namespace_with_namespaceless_from_and_namespace_false.should == 'namespaceless node'
+          expect(@instance.default_namespace_with_namespaceless_from_and_namespace_false).to eq('namespaceless node')
         end
       end
 
       context "and an explicit :namespace" do
         it "should use the explicit namespace" do
-          @instance.default_namespace_with_namespaceless_from_and_explicit_namespace.should == 'explicit namespace node'
+          expect(@instance.default_namespace_with_namespaceless_from_and_explicit_namespace).to eq('explicit namespace node')
         end
       end
     end
 
     context "with a namespacey :from" do
       it "should use the :from namespace" do
-        @instance.default_namespace_with_namespacey_from.should == 'namespacey node'
+        expect(@instance.default_namespace_with_namespacey_from).to eq('namespacey node')
+      end
+    end
+
+    context "with an namespacey XPath :from" do
+      it "should use the given namespace" do
+        expect(@instance.default_namespace_with_namespacey_xpath_from).to eq('namespacey xpath node')
+      end
+    end
+
+    context "with an XPath :from" do
+      it "should use the default namespace" do
+        expect(@instance.default_namespace_with_xpath_from).to eq('default namespace with xpath node')
       end
     end
   end
@@ -139,6 +150,8 @@ EOS
       xml_reader :default_namespace_with_namespaceless_from_and_explicit_namespace, :from => 'with_namespaceless_from', :namespace => 'explicit'
       xml_reader :default_namespace_with_namespaceless_from_and_namespace_false, :from => 'with_namespaceless_from', :namespace => false
       xml_reader :default_namespace_with_namespacey_from, :from => 'namespacey:with_namespacey_from'
+      xml_reader :default_namespace_with_namespacey_xpath_from, :from => 'xpath/namespacey:default_namespace'
+      xml_reader :default_namespace_with_xpath_from, :from => 'xpath/default_namespace'
 
       # These are handled in the "roxml namespacey declaration" shared spec
       # xml_reader :default_namespace_with_namespacey_from_and_namespace_false, :from => 'namespacey:with_namespaceless_from', :namespace => false
@@ -155,6 +168,8 @@ EOS
           <default_declared:with_namespaceless_from>default namespace node</default_declared:with_namespaceless_from>
           <explicit:default_and_explicit_namespace>explicit namespace node</explicit:default_and_explicit_namespace>
           <default_namespace_with_namespace_false>namespaceless node</default_namespace_with_namespace_false>
+          <default_declared:xpath><namespacey:default_namespace>namespacey xpath node</namespacey:default_namespace></default_declared:xpath>
+          <default_declared:xpath><default_declared:default_namespace>default namespace with xpath node</default_declared:default_namespace></default_declared:xpath>
         </book>
       })
     end
@@ -172,6 +187,8 @@ EOS
       xml_reader :default_namespace_with_namespaceless_from_and_explicit_namespace, :from => 'with_namespaceless_from', :namespace => 'explicit'
       xml_reader :default_namespace_with_namespaceless_from_and_namespace_false, :from => 'with_namespaceless_from', :namespace => false
       xml_reader :default_namespace_with_namespacey_from, :from => 'namespacey:with_namespacey_from'
+      xml_reader :default_namespace_with_namespacey_xpath_from, :from => 'xpath/namespacey:default_namespace'
+      xml_reader :default_namespace_with_xpath_from, :from => 'xpath/default_namespace'
 
       # These are handled in the "roxml namespacey declaration" shared spec
       # xml_reader :default_namespace_with_namespacey_from_and_namespace_false, :from => 'namespacey:with_namespaceless_from', :namespace => false
@@ -188,6 +205,8 @@ EOS
           <with_namespaceless_from>default namespace node</with_namespaceless_from>
           <explicit:default_and_explicit_namespace>explicit namespace node</explicit:default_and_explicit_namespace>
           <default_namespace_with_namespace_false xmlns="">namespaceless node</default_namespace_with_namespace_false>
+          <xpath><namespacey:default_namespace>namespacey xpath node</namespacey:default_namespace></xpath>
+          <xpath><default_namespace>default namespace with xpath node</default_namespace></xpath>
         </book>
       })
     end
@@ -228,42 +247,42 @@ EOS
     it_should_behave_like "roxml namespacey declaration"
 
     it "should find the namespace-less node" do
-      @instance.no_default_namespace.should == 'namespaceless node'
+      expect(@instance.no_default_namespace).to eq('namespaceless node')
     end
 
     context "with :namespace => false" do
       it "should find the namespace-less node" do
-        @instance.no_default_namespace_with_namespace_false.should == 'namespaceless node'
+        expect(@instance.no_default_namespace_with_namespace_false).to eq('namespaceless node')
       end
     end
 
     context "with an explicit :namespace" do
       it "should use the explicit namespace" do
-        @instance.no_default_but_an_explicit_namespace.should == 'explicit namespace node'
+        expect(@instance.no_default_but_an_explicit_namespace).to eq('explicit namespace node')
       end
     end
 
     context "with a namespace-less :from" do
       it "should find the namespace-less node" do
-        @instance.no_default_namespace_with_namespaceless_from.should == 'namespaceless node'
+        expect(@instance.no_default_namespace_with_namespaceless_from).to eq('namespaceless node')
       end
     
       context "and an explicit :namespace" do
         it "should use the explicit namespace" do
-          @instance.no_default_namespace_with_namespaceless_from_and_explicit_namespace.should == 'explicit namespace node'
+          expect(@instance.no_default_namespace_with_namespaceless_from_and_explicit_namespace).to eq('explicit namespace node')
         end
       end
 
       context "with :namespace => false" do
         it "should find the namespace-less node" do
-          @instance.no_default_namespace_with_namespaceless_from_and_namespace_false.should == 'namespaceless node'
+          expect(@instance.no_default_namespace_with_namespaceless_from_and_namespace_false).to eq('namespaceless node')
         end
       end
     end
 
     context "with a namespacey :from" do
       it "should use the :from namespace" do
-        @instance.no_default_namespace_with_namespacey_from.should == 'namespacey node'
+        expect(@instance.no_default_namespace_with_namespacey_from).to eq('namespacey node')
       end
     end
   end

data/spec/xml/namespaces_spec.rb

@@ -25,16 +25,16 @@ describe ROXML, "#xml_namespaces" do
     end
 
     it "should remap default namespaces" do
-      Tires.from_xml(@xml).car_tires.should =~ ['super slick racing tire', 'all weather tire']
+      expect(Tires.from_xml(@xml).car_tires).to match_array(['super slick racing tire', 'all weather tire'])
     end
 
     it "should remap prefix namespaces" do
-      Tires.from_xml(@xml).bike_tires.should == ['skinny street']
+      expect(Tires.from_xml(@xml).bike_tires).to eq(['skinny street'])
     end
 
     context "with namespace-indifferent option" do
       it "should return all tires" do
-        Tires.from_xml(@xml).tires.should =~ ['super slick racing tire', 'all weather tire', 'skinny street']
+        expect(Tires.from_xml(@xml).tires).to match_array(['super slick racing tire', 'all weather tire', 'skinny street'])
       end
     end
   end

data/spec/xml/object_spec.rb

@@ -28,7 +28,7 @@ describe ROXML::XMLObjectRef do
     end
 
     it "should return one instance" do
-      @ref.value_in(@xml).value.should == "first"
+      expect(@ref.value_in(@xml).value).to eq("first")
     end
     it "should output one instance"
   end
@@ -39,13 +39,13 @@ describe ROXML::XMLObjectRef do
     end
 
     it "should collect all instances" do
-      @ref.value_in(@xml).map(&:value).should == ["first", "second", "third"]
+      expect(@ref.value_in(@xml).map(&:value)).to eq(["first", "second", "third"])
     end
 
     it "should output all instances" do
       xml = ROXML::XML.new_node('myxml')
       @ref.update_xml(xml, ["first", "second", "third"].map {|value| SubObject.new(value) })
-      xml.to_s.squeeze(' ').should == @xml.root.to_s.squeeze(' ')
+      expect(xml.to_s.squeeze(' ')).to eq(@xml.root.to_s.squeeze(' '))
     end
   end
   
@@ -67,15 +67,15 @@ describe ROXML::XMLObjectRef do
       end
 
       it "should collect all instances" do
-        pending "Test bug?"
-        @ref.value_in(@xml).map(&:value).should == ["first", "second", "third"]
+        skip "Test bug?"
+        expect(@ref.value_in(@xml).map(&:value)).to eq(["first", "second", "third"])
       end
 
       it "should output all instances with namespaces" do
-        pending "Full namespace write support"
+        skip "Full namespace write support"
         xml = ROXML::XML.new_node('myxml')
         @ref.update_xml(xml, ["first", "second", "third"].map {|value| SubObject.new(value) })
-        xml.should == @xml.root
+        expect(xml).to eq(@xml.root)
       end
     end
   end

data/spec/xml/parser_spec.rb

@@ -1,21 +1,15 @@
 require_relative './../spec_helper.rb'
 
 describe ROXML::XML do
-  it "should raise on malformed xml" do
-    if ROXML::XML_PARSER == 'libxml' # nokogiri is less strict and auto-closes for some reason
-      proc { Book.from_xml(fixture(:book_malformed)) }.should raise_error(LibXML::XML::Error)
-    end
-  end
-
   it "should escape invalid characters on output to text node" do
     node = ROXML::XML.new_node("entities")
     ROXML::XML.set_content(node, " < > ' \" & ")
-    node.to_s.should == "<entities> &lt; &gt; ' \" &amp; </entities>"
+    expect(node.to_s).to eq("<entities> &lt; &gt; ' \" &amp; </entities>")
   end
 
   it "should esape invalid characters for attribute name" do
     node = ROXML::XML.new_node("attr_holder")
     ROXML::XML.set_attribute(node, "entities", "\"'<>&")
-    node.to_s.should == %{<attr_holder entities="&quot;'&lt;&gt;&amp;"/>}
+    expect(node.to_s).to eq(%{<attr_holder entities="&quot;'&lt;&gt;&amp;"/>})
   end
 end

data/spec/xml/text_spec.rb

@@ -18,7 +18,7 @@ describe ROXML::XMLTextRef do
     end
 
     it "should return one instance" do
-      @ref.value_in(@xml).should == "first"
+      expect(@ref.value_in(@xml)).to eq("first")
     end
     it "should output one instance"
   end
@@ -29,13 +29,13 @@ describe ROXML::XMLTextRef do
     end
 
     it "should collect all instances" do
-      @ref.value_in(@xml).should == ["first", "second", "third"]
+      expect(@ref.value_in(@xml)).to eq(["first", "second", "third"])
     end
 
     it "should output all instances" do
       xml = ROXML::XML.new_node('myxml')
       @ref.update_xml(xml, ["first", "second", "third"])
-      xml.to_s.squeeze(' ').should == @xml.root.to_s.squeeze(' ')
+      expect(xml.to_s.squeeze(' ')).to eq(@xml.root.to_s.squeeze(' '))
     end
   end
   
@@ -57,14 +57,14 @@ describe ROXML::XMLTextRef do
       end
 
       it "should collect all instances" do
-        @ref.value_in(@xml).should == ["first", "second", "third"]
+        expect(@ref.value_in(@xml)).to eq(["first", "second", "third"])
       end
 
       it "should output all instances with namespaces" do
-        pending "Full namespace write support"
+        skip "Full namespace write support"
         xml = ROXML::XML.new_node('myxml')
         @ref.update_xml(xml, ["first", "second", "third"])
-        xml.should == @xml.root
+        expect(xml).to eq(@xml.root)
       end
     end
   end