roxml 3.2.2 → 4.1.1

data/spec/examples/active_record_spec.rb

@@ -8,30 +8,30 @@ describe ROXML, "under ActiveRecord" do
   end
 
   it "should be parsed" do
-    @route.should_not == nil
-    @route.should be_an_instance_of(Route)
+    expect(@route).to_not eq(nil)
+    expect(@route).to be_an_instance_of(Route)
   end
 
   describe "xml attributes" do
     it "should extract xml attributes" do
-      @route.totalHg.should == "640"
-      @route.lonlatx.should == "357865"
-      @route.lonlaty.should == "271635"
-      @route.grcenter.should == "SH 71635 57865"
-      @route.totalMins.should == "235.75000000000003"
-      @route.totalDist.should == "11185.321521477119"
+      expect(@route.totalHg).to eq("640")
+      expect(@route.lonlatx).to eq("357865")
+      expect(@route.lonlaty).to eq("271635")
+      expect(@route.grcenter).to eq("SH 71635 57865")
+      expect(@route.totalMins).to eq("235.75000000000003")
+      expect(@route.totalDist).to eq("11185.321521477119")
     end
   end
 
   describe "xml sub-objects" do
     it "should extract xml sub-objects" do
-      @route.should have(6).waypoints
-      @route.waypoints.each {|waypoint| waypoint.should be_an_instance_of(Waypoint)}
+      expect(@route.waypoints.size).to eq(6)
+      @route.waypoints.each {|waypoint| expect(waypoint).to be_an_instance_of(Waypoint)}
     end
     it "should be usable as a ActiveRecord object" do
-      Waypoint.count.should == 0
+      expect(Waypoint.count).to eq(0)
       @route.save!
-      Waypoint.count.should == 6
+      expect(Waypoint.count).to eq(6)
     end
   end
-end
+end

data/spec/examples/amazon_spec.rb

@@ -8,26 +8,26 @@ describe PITA::ItemSearchResponse do
 
   describe "#total_results" do
     it "should be parsed as a number" do
-      @response.total_results.should > 0
+      expect(@response.total_results).to be > 0
     end
   end
 
   describe "#total_pages" do
     it "should be parsed as a number" do
-      @response.total_pages.should > 0
+      expect(@response.total_pages).to be > 0
     end
   end
 
   describe "#items" do
     it "should return a collection of items" do
-      @response.items.should be_an_instance_of(Array)
-      @response.items.size.should > 0
-      @response.items.each {|item| item.should be_an_instance_of(PITA::Item) }
+      expect(@response.items).to be_an_instance_of(Array)
+      expect(@response.items.size).to be > 0
+      @response.items.each {|item| expect(item).to be_an_instance_of(PITA::Item) }
     end
 
     it "should have the some number less than or equal to #total_results" do
-      @response.items.size.should > 0
-      @response.items.size.should <= @response.total_results
+      expect(@response.items.size).to be > 0
+      expect(@response.items.size).to be <= @response.total_results
     end
   end
 end
@@ -38,17 +38,17 @@ describe PITA::Item do
   end
 
   it "should extract asin" do
-    @items.each {|item| item.asin.should be_an_instance_of(String) }
-    @items.each {|item| item.asin.should_not be_empty }
+    @items.each {|item| expect(item.asin).to be_an_instance_of(String) }
+    @items.each {|item| expect(item.asin).to_not be_empty }
   end
 
   it "should extract detail_page_url" do
-    @items.each {|item| item.detail_page_url.should be_an_instance_of(String) }
-    @items.each {|item| item.detail_page_url.should_not be_empty }
+    @items.each {|item| expect(item.detail_page_url).to be_an_instance_of(String) }
+    @items.each {|item| expect(item.detail_page_url).to_not be_empty }
   end
 
   it "should extract manufacturer" do
-    @items.each {|item| item.manufacturer.should be_an_instance_of(String) }
-    @items.each {|item| item.manufacturer.should_not be_empty }
+    @items.each {|item| expect(item.manufacturer).to be_an_instance_of(String) }
+    @items.each {|item| expect(item.manufacturer).to_not be_empty }
   end
 end

data/spec/examples/current_weather_spec.rb

@@ -7,7 +7,7 @@ describe Weather do
   end
 
   it "should extract observations" do
-    @weather.observation.should be_an_instance_of(WeatherObservation)
+    expect(@weather.observation).to be_an_instance_of(WeatherObservation)
   end
 end
 
@@ -17,21 +17,21 @@ describe WeatherObservation do
   end
 
   it "should extract temperature" do
-    @observation.temperature.should > 0
+    expect(@observation.temperature).to be > 0
   end
 
   it "should extract feels_like" do
-    @observation.feels_like.should > 0
+    expect(@observation.feels_like).to be > 0
   end
 
   describe "#current_condition" do
     it "should extract current_condition" do
-      @observation.current_condition.should_not be_empty
+      expect(@observation.current_condition).to_not be_empty
     end
 
     it "should extract icon attribute" do
-      pending "need to think options through for HappyMapper-style :attributes extensions"
-      @observation.current_condition.icon.should_not be_empty
+      skip "need to think options through for HappyMapper-style :attributes extensions"
+      expect(@observation.current_condition.icon).to_not be_empty
     end
   end
 end

data/spec/examples/dashed_elements_spec.rb

@@ -7,14 +7,14 @@ describe GitHub::Commit do
   end
 
   it "should extract committed date" do
-    @commit.committed_date.should be_an_instance_of(Date)
+    expect(@commit.committed_date).to be_an_instance_of(Date)
   end
 
   it "should extract url" do
-    @commit.url.should_not be_empty
+    expect(@commit.url).to_not be_empty
   end
 
   it "should extract id" do
-    @commit.id.should_not be_empty
+    expect(@commit.id).to_not be_empty
   end
 end

data/spec/examples/library_spec.rb

@@ -17,7 +17,7 @@ describe Library do
 
   describe "#to_xml" do
     it "should contain the expected information" do
-      @lib.to_xml.to_s.should == ROXML::XML.parse_string(%{<library><NAME><![CDATA[Favorite Books]]></NAME><novel ISBN='0201710897'><title>The PickAxe</title><description><![CDATA[Best Ruby book out there!]]></description><author>David Thomas, Andrew Hunt, Dave Thomas</author><publisher><name>Addison Wesley Longman, Inc.</name></publisher></novel></library>}).root.to_s
+      expect(@lib.to_xml.to_s).to eq(ROXML::XML.parse_string(%{<library><NAME><![CDATA[Favorite Books]]></NAME><novel ISBN='0201710897'><title>The PickAxe</title><description><![CDATA[Best Ruby book out there!]]></description><author>David Thomas, Andrew Hunt, Dave Thomas</author><publisher><name>Addison Wesley Longman, Inc.</name></publisher></novel></library>}).root.to_s)
     end
 
     context "when written to a file" do
@@ -33,12 +33,12 @@ describe Library do
      end
 
      it "should be contain the expected xml" do
-        ROXML::XML.parse_string(File.read(@path)).to_s.should == ROXML::XML.parse_string(%{<?xml version="1.0"?><library><NAME><![CDATA[Favorite Books]]></NAME><novel ISBN='0201710897'><title>The PickAxe</title><description><![CDATA[Best Ruby book out there!]]></description><author>David Thomas, Andrew Hunt, Dave Thomas</author><publisher><name>Addison Wesley Longman, Inc.</name></publisher></novel></library>}).to_s
+        expect(ROXML::XML.parse_string(File.read(@path)).to_s).to eq(ROXML::XML.parse_string(%{<?xml version="1.0"?><library><NAME><![CDATA[Favorite Books]]></NAME><novel ISBN='0201710897'><title>The PickAxe</title><description><![CDATA[Best Ruby book out there!]]></description><author>David Thomas, Andrew Hunt, Dave Thomas</author><publisher><name>Addison Wesley Longman, Inc.</name></publisher></novel></library>}).to_s)
       end
 
       it "should be re-parsable via .from_xml" do
         File.open("spec/examples/library.xml") do |file|
-          Library.from_xml(file).should == @lib
+          expect(Library.from_xml(file)).to eq(@lib)
         end
       end
     end

data/spec/examples/library_with_fines_spec.rb

@@ -7,10 +7,10 @@ describe LibraryWithFines do
   let(:library) { LibraryWithFines.from_xml(xml) }
 
   it "should read nested elements" do
-    library.fines.should be_a(Hash)
+    expect(library.fines).to be_a(Hash)
     library.fines.size == 3
-    library.fines.should have_key('talking')
-    library.fines['talking'].should match(/Stop asking/)
+    expect(library.fines).to have_key('talking')
+    expect(library.fines['talking']).to match(/Stop asking/)
   end
 
   class String
@@ -21,17 +21,17 @@ describe LibraryWithFines do
 
   it "should write deeply nested elements" do
     xml_out = library.to_xml.to_s
-    xml_out.remove_whitespace.should == xml.remove_whitespace
+    expect(xml_out.remove_whitespace).to eq(xml.remove_whitespace)
   end
 
   it "should write two children of library: name and policy" do
-    library.to_xml.children.map{|e| e.name }.should == ['name', 'policy']
+    expect(library.to_xml.children.map{|e| e.name }).to eq(['name', 'policy'])
   end
 
   it "should be re-parsable via .from_xml" do
     lib_reparsed = LibraryWithFines.from_xml(library.to_xml.to_s)
-    lib_reparsed.name.should == library.name
-    lib_reparsed.fines.should == library.fines
+    expect(lib_reparsed.name).to eq(library.name)
+    expect(lib_reparsed.fines).to eq(library.fines)
   end
 
 

data/spec/examples/person_spec.rb

@@ -2,36 +2,36 @@ require 'spec_helper'
 require_relative './../../examples/person'
 
 describe Person do
-	
-	before do
-		@person = Person.new
-		@person.name = 'John Doe'
-		@person.lat = '40.715224'
-		@person.long = '-74.005966'
-		@person.street = 'Evergreen Terrace'
-		@person.city = 'Springfield'
-		@person.zip = '2342'
-	end
 
-	it 'should only contain one location element' do
-		@person.to_xml.roxml_search('location').count.should == 1
-	end
+  before do
+    @person = Person.new
+    @person.name = 'John Doe'
+    @person.lat = '40.715224'
+    @person.long = '-74.005966'
+    @person.street = 'Evergreen Terrace'
+    @person.city = 'Springfield'
+    @person.zip = '2342'
+  end
 
-	describe '#to_xml' do
-		before do
-			@xml_generated = @person.to_xml.to_s.gsub("\n",'').squeeze(' ')
-		end
+  it 'should only contain one location element' do
+    expect(ROXML::XML.search(@person.to_xml, 'location').count).to eq(1)
+  end
 
-		it 'should generate the expected xml' do
-			xml_file = File.read(xml_for('person')).gsub("\n",'').squeeze(' ')
-			xml_file.should == @xml_generated
-		end
+  describe '#to_xml' do
+    before do
+      @xml_generated = @person.to_xml.to_s.gsub("\n",'').squeeze(' ')
+    end
 
-		it 'should generate identical xml after a full roundtrip' do	
-			p = Person.from_xml(@xml_generated)
-			xml_roundtrip = p.to_xml.to_s.gsub("\n",'').squeeze(' ')
-			xml_roundtrip.should == @xml_generated
-		end
-	end
+    it 'should generate the expected xml' do
+      xml_file = File.read(xml_for('person')).gsub("\n",'').squeeze(' ')
+      expect(xml_file).to eq(@xml_generated)
+    end
+
+    it 'should generate identical xml after a full roundtrip' do
+      p = Person.from_xml(@xml_generated)
+      xml_roundtrip = p.to_xml.to_s.gsub("\n",'').squeeze(' ')
+      expect(xml_roundtrip).to eq(@xml_generated)
+    end
+  end
 
 end

data/spec/examples/post_spec.rb

@@ -7,18 +7,18 @@ describe Post do
   end
 
   it "should extract description" do
-    @posts.each {|post| post.description.should_not be_empty }
+    @posts.each {|post| expect(post.description).to_not be_empty }
   end
 
   it "should extract href" do
-    @posts.each {|post| post.href.should_not be_empty }
+    @posts.each {|post| expect(post.href).to_not be_empty }
   end
 
   it "should extract extended" do
-    @posts.each {|post| post.extended.should_not be_empty }
+    @posts.each {|post| expect(post.extended).to_not be_empty }
   end
 
   it "should extract time" do
-    @posts.each {|post| post.created_at.should be_an_instance_of(DateTime) }
+    @posts.each {|post| expect(post.created_at).to be_an_instance_of(DateTime) }
   end
 end

data/spec/examples/search_query_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+require_relative './../../examples/search_query'
+
+describe SearchQuery do	
+
+	before do
+		@search = SearchQuery.new
+		@search.query = 'This is a random search query.'
+
+		@saved_search = SearchQuery.from_xml("<searchquery><query>Search for something</query></searchquery>")
+	end
+
+	it 'should return the default value for all attributes where no value is set' do
+		expect(@search.language).to eq('EN')
+		@search.max_results == 20
+	end
+
+	it 'should return the same object for the default value' do
+		expect(@search.language.object_id).to eq(@search.language.object_id)
+	end
+
+	it 'should respect the defaults when loading from xml' do
+		expect(@saved_search.language).to eq('EN')
+		@saved_search.max_results == 20
+	end
+end

data/spec/examples/twitter_spec.rb

@@ -8,11 +8,11 @@ describe Statuses do
     end
 
     it "should extract text" do
-      @statuses.each {|status| status.text.should_not be_empty }
+      @statuses.each {|status| expect(status.text).to_not be_empty }
     end
 
     it "should extract source" do
-      @statuses.each {|status| status.source.should_not be_empty }
+      @statuses.each {|status| expect(status.source).to_not be_empty }
     end
 
     describe User do
@@ -21,11 +21,11 @@ describe Statuses do
       end
 
       it "should extract name" do
-        @users.each {|user| user.name.should == "John Nunemaker" }
+        @users.each {|user| expect(user.name).to eq("John Nunemaker") }
       end
 
       it "should extract screen_name" do
-        @users.each {|user| user.screen_name.should == "jnunemaker" }
+        @users.each {|user| expect(user.screen_name).to eq("jnunemaker") }
       end
     end
   end

data/spec/reference_spec.rb

@@ -23,12 +23,12 @@ describe ROXML::XMLRef do
 
   it "should properly reconstruct wrappers with multiple elements" do
 
-    reference.should be_a(ROXML::XMLHashRef)
+    expect(reference).to be_a(ROXML::XMLHashRef)
 
     xml = ROXML::XML.new_node('org').tap do |root|
       reference.update_xml(root, org.fines)
     end
 
-    xml_path( xml ).should == %w{org policy fines fine name}
+    expect(xml_path( xml )).to eq(%w{org policy fines fine name})
   end
 end

data/spec/regression_spec.rb

@@ -4,16 +4,21 @@ describe ROXML do
   describe 'frozen nils' do
     subject { nil }
 
-    context 'before unmarshalling an XML document' do
-      it { should_not be_frozen }
-    end
-
-    context 'after unmarshalling an XML document' do
-      before do
-        lib = Library.from_xml(fixture(:library))
+    # Prior to ruby-2.2, nil was not frozen. This test watches for
+    # a regression in previous versions of roxml that caused nil to
+    # become frozen.  FIXME: remove after ruby-2.1 support is removed.
+    if RUBY_VERSION < "2.2"
+      context 'before unmarshalling an XML document' do
+        it { is_expected.to_not be_frozen }
       end
 
-      it { should_not be_frozen }
+      context 'after unmarshalling an XML document' do
+        before do
+          lib = Library.from_xml(fixture(:library))
+        end
+
+        it { is_expected.to_not be_frozen }
+      end
     end
   end
 end

data/spec/roxml_spec.rb

@@ -1,34 +1,42 @@
 require_relative './spec_helper'
 
-describe ROXML, "#from_xml" do
-  shared_examples_for "from_xml call" do
-    it "should fetch values" do
-      book = BookWithContributors.from_xml(@path)
-      book.title.should == "Programming Ruby - 2nd Edition"
-      book.contributors.map(&:name).should == ["David Thomas","Andrew Hunt","Chad Fowler"]
+describe ROXML do
+  describe "::VERSION" do
+    it "should be equal to the VERSION file contents" do
+      expect(ROXML::VERSION).to eq(File.read('VERSION'))
     end
   end
 
-  context "called with PathName" do
-    before do
-      @path = Pathname.new(fixture_path(:book_with_contributors))
+  describe "#from_xml" do
+    shared_examples_for "from_xml call" do
+      it "should fetch values" do
+        book = BookWithContributors.from_xml(@path)
+        expect(book.title).to eq("Programming Ruby - 2nd Edition")
+        expect(book.contributors.map(&:name)).to eq(["David Thomas","Andrew Hunt","Chad Fowler"])
+      end
     end
-    it_should_behave_like "from_xml call"
-  end
 
-  context "called with File" do
-    before do
-      @path = File.new(fixture_path(:book_with_contributors))
+    context "called with PathName" do
+      before do
+        @path = Pathname.new(fixture_path(:book_with_contributors))
+      end
+      it_should_behave_like "from_xml call"
     end
-    it_should_behave_like "from_xml call"
-  end
 
-  context "called with URI" do
-    before do
-      require 'uri'
-      @path = URI.parse("file://#{File.expand_path(File.expand_path(fixture_path(:book_with_contributors)))}")
+    context "called with File" do
+      before do
+        @path = File.new(fixture_path(:book_with_contributors))
+      end
+      it_should_behave_like "from_xml call"
+    end
+
+    context "called with URI" do
+      before do
+        require 'uri'
+        @path = URI.parse("file://#{File.expand_path(File.expand_path(fixture_path(:book_with_contributors)))}")
+      end
+      it_should_behave_like "from_xml call"
     end
-    it_should_behave_like "from_xml call"
   end
 end
 
@@ -73,14 +81,14 @@ describe ROXML, "#xml" do
   end
 
   it "should raise on duplicate accessor name" do
-    proc do
+    expect do
       Class.new do
         include ROXML
 
         xml_reader :id
         xml_accessor :id
       end
-    end.should raise_error(RuntimeError)
+    end.to raise_error(RuntimeError)
   end
 
   class OctalInteger
@@ -131,19 +139,6 @@ describe ROXML, "#xml" do
       @expected_pages = 239
     end
 
-    describe "with :as block shorthand" do
-      class BookWithOctalPagesBlockShorthand
-        include ROXML
-
-        xml_accessor :pages, :as => Integer, :required => true
-      end
-
-      it "should apply filtering on input" do
-        book = BookWithOctalPagesBlockShorthand.from_xml(@book_with_octal_pages_xml)
-        book.pages.should == @expected_pages
-      end
-    end
-
     describe "with #from_xml defined on the object" do
       class BookWithOctalPagesType
         include ROXML
@@ -153,7 +148,7 @@ describe ROXML, "#xml" do
 
       it "should apply filtering on input" do
         book = BookWithOctalPagesType.from_xml(@book_with_octal_pages_xml)
-        book.pages.should == @expected_pages
+        expect(book.pages).to eq(@expected_pages)
       end
     end
   end
@@ -186,11 +181,11 @@ describe ROXML, "#xml" do
 
     describe "indirect reference via an object" do
       it "does not inherit the frozen status from its parent" do
-        @frozen.writable.frozen?.should be_false
-        @frozen.readonly.frozen?.should be_true
+        expect(@frozen.writable.frozen?).to be_falsey
+        expect(@frozen.readonly.frozen?).to be_truthy
 
-        @unfrozen.writable.frozen?.should be_false
-        @unfrozen.readonly.frozen?.should be_true
+        expect(@unfrozen.writable.frozen?).to be_falsey
+        expect(@unfrozen.readonly.frozen?).to be_truthy
       end
     end
   end
@@ -204,8 +199,8 @@ describe ROXML, "#xml" do
     it_should_behave_like "freezable xml reference"
 
     it "should apply :frozen to the constituent elements" do
-      @frozen.all?(&:frozen?).should be_true
-      @unfrozen.any?(&:frozen?).should be_false
+      expect(@frozen.all?(&:frozen?)).to be_truthy
+      expect(@unfrozen.any?(&:frozen?)).to be_falsey
     end
 
     context "no elements are present in root, no :in is specified" do
@@ -229,7 +224,7 @@ describe ROXML, "#xml" do
             </contributors>
           </book>
         })
-        book.contributors.map(&:name).sort.should == ["David Thomas","Andrew Hunt","Chad Fowler"].sort
+        expect(book.contributors.map(&:name).sort).to eq(["David Thomas","Andrew Hunt","Chad Fowler"].sort)
       end
     end
   end
@@ -259,13 +254,13 @@ describe ROXML, "#xml" do
     it_should_behave_like "freezable xml reference"
 
     it "should have frozen keys, as with all hashes" do
-      @frozen.keys.all?(&:frozen?).should be_true
-      @unfrozen.keys.all?(&:frozen?).should be_true
+      expect(@frozen.keys.all?(&:frozen?)).to be_truthy
+      expect(@unfrozen.keys.all?(&:frozen?)).to be_truthy
     end
 
     it "should apply :frozen to the constituent values" do
-      @frozen.values.all?(&:frozen?).should be_true
-      @unfrozen.values.any?(&:frozen?).should be_false
+      expect(@frozen.values.all?(&:frozen?)).to be_truthy
+      expect(@unfrozen.values.any?(&:frozen?)).to be_falsey
     end
   end
 end
@@ -335,29 +330,29 @@ describe ROXML, "inheritance" do
 
   describe "parent" do
     it "should include its attributes" do
-      @child.isbn.should == "0201710897"
-      @child.title.should == "The PickAxe"
-      @child.description.should == "Probably the best Ruby book out there"
-      @child.author.should == 'David Thomas, Andrew Hunt, Dave Thomas'
-      @child.pages.should == nil
+      expect(@child.isbn).to eq("0201710897")
+      expect(@child.title).to eq("The PickAxe")
+      expect(@child.description).to eq("Probably the best Ruby book out there")
+      expect(@child.author).to eq('David Thomas, Andrew Hunt, Dave Thomas')
+      expect(@child.pages).to eq(nil)
     end
     
     it "should not include its child's attributes" do
-      @parent.should_not respond_to(:depth)
+      expect(@parent).to_not respond_to(:depth)
     end
   end
   
   describe "child" do
     it "should include its parent's attributes" do
-      @child.isbn.should == @parent.isbn
-      @child.title.should == @parent.title
-      @child.description.should == @parent.description
-      @child.author.should == @parent.author
-      @child.pages.should == @parent.pages
+      expect(@child.isbn).to eq(@parent.isbn)
+      expect(@child.title).to eq(@parent.title)
+      expect(@child.description).to eq(@parent.description)
+      expect(@child.author).to eq(@parent.author)
+      expect(@child.pages).to eq(@parent.pages)
     end
 
     it "should include its attributes" do
-      @child.depth.to_s.should == '11.3 meters'
+      expect(@child.depth.to_s).to eq('11.3 meters')
     end
 
     it "should include parent's attributes added after declaration" do
@@ -366,7 +361,7 @@ describe ROXML, "inheritance" do
       end
 
       book = InheritedBookWithDepth.from_xml(@book_xml)
-      book.publisher.should == "Pragmattic Programmers"
+      expect(book.publisher).to eq("Pragmattic Programmers")
     end
   end
 end