om 1.8.0 → 1.8.1

data/om.gemspec

@@ -17,11 +17,10 @@ Gem::Specification.new do |s|
   s.add_dependency('nokogiri', ">= 1.4.2")
   s.add_dependency('mediashelf-loggable')
   s.add_dependency('deprecation')
-  s.add_development_dependency "rspec", "~> 2.0"
+  s.add_development_dependency "rspec", "~> 2.99"
   s.add_development_dependency "rake"
   s.add_development_dependency "rdoc"
   s.add_development_dependency "awesome_print"
-  s.add_development_dependency "mocha", ">= 0.9.8"
   s.add_development_dependency "equivalent-xml", ">= 0.2.4"
 
   s.files         = `git ls-files`.split("\n")

data/spec/integration/differentiated_elements_spec.rb

@@ -30,10 +30,10 @@ describe "use the root element as a member of the proxy address" do
   end
 
   it "should pull out all occurences of the_thing_we_want in the relevant_container" do
-    subject.relevant_container.the_thing_we_want.should == ["1", "2"]
+    expect(subject.relevant_container.the_thing_we_want).to eq(["1", "2"])
   end
 
   it "should only pull out the_thing_we_want at the root level" do
-    subject.the_thing_we_want.should == ["2"]
+    expect(subject.the_thing_we_want).to eq(["2"])
   end
 end

data/spec/integration/element_value_spec.rb

@@ -53,39 +53,39 @@ EOF
 end
 
   it "should handle single-element terms correctly" do
-    subject.elementA.should == ["valA"]
+    expect(subject.elementA).to eq(["valA"])
   end
 
   it "should handle term paths" do
-    subject.elC.should == ["valC"]
+    expect(subject.elC).to eq(["valC"])
   end
 
   it "should handle multiple-element, terms with paths correctly" do
-    subject.elB.should == ["valB1", "valB2"]
+    expect(subject.elB).to eq(["valB1", "valB2"])
   end
 
   it "should handle terms that require specific attributes" do
-    subject.elementC.should == ["valC"]
+    expect(subject.elementC).to eq(["valC"])
   end
 
   it "should handle" do
-    subject.here.length.should == 1
-    subject.here.first.split(/\W/).should include('123', '456')
+    expect(subject.here.length).to eq(1)
+    expect(subject.here.first.split(/\W/)).to include('123', '456')
   end
 
   it "should handle missing terms" do
-    subject.there.should be_empty
+    expect(subject.there).to be_empty
   end
 
   it "should handle element  value given the absence of a specific attribute" do
-    subject.elementD.should == ["valD1"]
-    subject.no_attrib.should == ["valB1"]
+    expect(subject.elementD).to eq(["valD1"])
+    expect(subject.no_attrib).to eq(["valB1"])
   end
 
   it "should handle OM terms for an attribute value" do
-    subject.elementB.my_attr.should == ["vole"]
-    subject.alternate.should == ["vole"]
-    subject.another.should == ["vole"]
-    subject.animal_attrib.should include("vole", "seagull")
+    expect(subject.elementB.my_attr).to eq(["vole"])
+    expect(subject.alternate).to eq(["vole"])
+    expect(subject.another).to eq(["vole"])
+    expect(subject.animal_attrib).to include("vole", "seagull")
   end
 end

data/spec/integration/proxies_and_ref_spec.rb

@@ -7,7 +7,7 @@ describe "an example with :proxy and :ref" do
 
       set_terminology do |t|
         t.root(:path => "outer", :xmlns => '', :namespace_prefix => nil)
-    
+
         t.resource(:namespace_prefix => nil) {
           t.fedora_pid(:path=>{:attribute=>"objectId"}, :namespace_prefix => nil)
           t.file(:ref=>[:file], :namespace_prefix => nil, :namespace_prefix => nil)
@@ -18,16 +18,16 @@ describe "an example with :proxy and :ref" do
           t.md5(:path=>"checksum", :attributes=>{:type=>"md5"}, :namespace_prefix => nil)
           t.sha1(:path=>"checksum", :attributes=>{:type=>"sha1"}, :namespace_prefix => nil)
         }
-        #  really want ead where the type is ead and the file format is XML and the file mimetype is text/xml (and the file id is (?coll_ead.xml ... can be whatever the label of the DS is in the FileAsset object)) 
-        t.ead(:ref=>:resource, :attributes=>{:type=>"ead"}) 
+        #  really want ead where the type is ead and the file format is XML and the file mimetype is text/xml (and the file id is (?coll_ead.xml ... can be whatever the label of the DS is in the FileAsset object))
+        t.ead(:ref=>:resource, :attributes=>{:type=>"ead"})
         t.image(:ref=>:resource, :attributes=>{:type=>"image"})
-    
+
         t.ead_fedora_pid(:proxy=>[:ead, :fedora_pid])
         t.ead_ds_label(:proxy=>[:ead, :file, :ds_label])
         t.ead_size(:proxy=>[:ead, :file, :size])
         t.ead_md5(:proxy=>[:ead, :file, :md5])
         t.ead_sha1(:proxy=>[:ead, :file, :sha1])
-    
+
         t.image_fedora_pid(:proxy=>[:image, :fedora_pid])
         t.image_ds_label(:proxy=>[:image, :file, :ds_label])
         t.image_size(:proxy=>[:image, :file, :size])
@@ -59,21 +59,21 @@ end
 
   describe "image" do
     it "should have the right proxy terms" do
-      subject.ead_fedora_pid.should include "hypatia:ead_file_asset_fixture"
-      subject.ead_ds_label.should include "my_ead.xml"
-      subject.ead_size.should include "47570"
-      subject.ead_md5.should include "123"
-      subject.ead_sha1.should include "456"
+      expect(subject.ead_fedora_pid).to include "hypatia:ead_file_asset_fixture"
+      expect(subject.ead_ds_label).to include "my_ead.xml"
+      expect(subject.ead_size).to include "47570"
+      expect(subject.ead_md5).to include "123"
+      expect(subject.ead_sha1).to include "456"
     end
   end
 
   describe "ead" do
     it "should have the right proxy terms" do
-      subject.image_fedora_pid.should include "hypatia:coll_img_file_asset_fixture"
-      subject.image_ds_label.should include "my_image.jpg"
-      subject.image_size.should include "302080"
-      subject.image_md5.should include "789"
-      subject.image_sha1.should include "666"
+      expect(subject.image_fedora_pid).to include "hypatia:coll_img_file_asset_fixture"
+      expect(subject.image_ds_label).to include "my_image.jpg"
+      expect(subject.image_size).to include "302080"
+      expect(subject.image_md5).to include "789"
+      expect(subject.image_sha1).to include "666"
     end
 
   end

data/spec/integration/querying_documents_spec.rb

@@ -12,31 +12,36 @@ describe "Rspec tests for QUERYING_DOCUMENTS.textile" do
   end
 
   it "xpath_for()" do
-    @term.xpath_for(:name).should == 
+    expect(@term.xpath_for(:name)).to eq(
       '//oxns:name'
-    @term.xpath_for(:person).should == 
+    )
+    expect(@term.xpath_for(:person)).to eq(
       '//oxns:name[@type="personal"]'
-    @term.xpath_for(:organization).should == 
+    )
+    expect(@term.xpath_for(:organization)).to eq(
       '//oxns:name[@type="corporate"]'
-    @term.xpath_for(:person, :first_name).should ==
+    )
+    expect(@term.xpath_for(:person, :first_name)).to eq(
       '//oxns:name[@type="personal"]/oxns:namePart[@type="given"]'
-    @term.xpath_for(:journal, :issue, :pages, :start).should ==
+    )
+    expect(@term.xpath_for(:journal, :issue, :pages, :start)).to eq(
       '//oxns:relatedItem[@type="host"]/oxns:part/oxns:extent[@unit="pages"]/oxns:start'
+    )
   end
 
   it "term_values()" do
-    @doc.term_values(:person, :first_name).should == ["GIVEN NAMES", "Siddartha"]
-    @doc.term_values(:person, :last_name).should == ["FAMILY NAME", "Gautama"]
-    @doc.term_values(:organization, :namePart).should == ['NSF']
-    @doc.term_values(:journal, :issue, :pages, :start).should == ['195']
-    @doc.term_values(:journal, :title_info, :main_title).should == ["TITLE OF HOST JOURNAL"]
+    expect(@doc.term_values(:person, :first_name)).to eq(["GIVEN NAMES", "Siddartha"])
+    expect(@doc.term_values(:person, :last_name)).to eq(["FAMILY NAME", "Gautama"])
+    expect(@doc.term_values(:organization, :namePart)).to eq(['NSF'])
+    expect(@doc.term_values(:journal, :issue, :pages, :start)).to eq(['195'])
+    expect(@doc.term_values(:journal, :title_info, :main_title)).to eq(["TITLE OF HOST JOURNAL"])
   end
 
   it "xpath_for(): relative vs absolute" do
     xp_rel = '//oxns:titleInfo/oxns:title'
     xp_abs = '//oxns:mods/oxns:titleInfo/oxns:title'
-    @term.xpath_for(       :title_info, :main_title).should == xp_rel
-    @term.xpath_for(:mods, :title_info, :main_title).should == xp_abs
+    expect(@term.xpath_for(       :title_info, :main_title)).to eq(xp_rel)
+    expect(@term.xpath_for(:mods, :title_info, :main_title)).to eq(xp_abs)
   end
 
   it "term_values(): relative vs absolute" do
@@ -46,16 +51,16 @@ describe "Rspec tests for QUERYING_DOCUMENTS.textile" do
       "TITLE OF HOST JOURNAL",
     ]
     xp_abs = '//oxns:mods/oxns:titleInfo/oxns:title'
-    @doc.term_values(       :title_info, :main_title).should == exp
-    @doc.term_values(:mods, :title_info, :main_title).should == exp[0..1]
+    expect(@doc.term_values(       :title_info, :main_title)).to eq(exp)
+    expect(@doc.term_values(:mods, :title_info, :main_title)).to eq(exp[0..1])
   end
 
   it "find_by_terms()" do
     exp_xml_role  = '<role><roleTerm authority="marcrelator" type="text">funder</roleTerm></role>'
     exp_xml_start = '<start>195</start>'
-    @doc.find_by_terms(:organization, :role).class.should == Nokogiri::XML::NodeSet
-    @doc.find_by_terms(:organization, :role).to_xml.should be_equivalent_to exp_xml_role
-    @doc.find_by_terms(:journal, :issue, :pages, :start).to_xml.should == exp_xml_start
+    expect(@doc.find_by_terms(:organization, :role).class).to eq(Nokogiri::XML::NodeSet)
+    expect(@doc.find_by_terms(:organization, :role).to_xml).to be_equivalent_to exp_xml_role
+    expect(@doc.find_by_terms(:journal, :issue, :pages, :start).to_xml).to eq(exp_xml_start)
   end
 
   it "find_by_terms() error" do
@@ -64,8 +69,9 @@ describe "Rspec tests for QUERYING_DOCUMENTS.textile" do
   end
 
   it "proxies" do
-    @term.xpath_for(:title).should ==
+    expect(@term.xpath_for(:title)).to eq(
       '//oxns:titleInfo/oxns:title'
+    )
     @term.xpath_for(:journal_title)
       '//oxns:relatedItem[@type="host"]/oxns:titleInfo/oxns:title'
   end

data/spec/integration/rights_metadata_integration_example_spec.rb

@@ -1,12 +1,12 @@
 require 'spec_helper'
 
 describe "OM::XML::Accessors" do
-  
+
   before(:all) do
     class RightsMDTest
-      
+
       include OM::XML::Document
-          
+
       terminology = OM::XML::Terminology::Builder.new do |t|
         t.rightsMetadata(:xmlns=>"http://hydra-collab.stanford.edu/schemas/rightsMetadata/v1", :schema=>"http://github.com/projecthydra/schemas/tree/v1/rightsMetadata.xsd") {
           t.access {
@@ -19,19 +19,19 @@ describe "OM::XML::Accessors" do
           t.edit_access(:variant_of=>:access, :attributes=>{:type=>"personal"})
         }
       end
-      # root_property :rightsMetadata, "rightsMetadata", "http://hydra-collab.stanford.edu/schemas/rightsMetadata/v1", :schema=>"http://github.com/projecthydra/schemas/tree/v1/rightsMetadata.xsd"          
-      # 
+      # root_property :rightsMetadata, "rightsMetadata", "http://hydra-collab.stanford.edu/schemas/rightsMetadata/v1", :schema=>"http://github.com/projecthydra/schemas/tree/v1/rightsMetadata.xsd"
+      #
       # property :access, :path=>"access",
       #             :subelements=>[:machine],
       #             :convenience_methods => {
       #               :human_readable => {:path=>"human"}
       #             }
-      #             
+      #
       # property :edit_access, :variant_of=>:access, :attributes=>{:type=>"edit"}
-      # 
+      #
       # property :machine, :path=>"machine",
       #             :subelements=>["group","person"]
-      
+
       # generate_accessors_from_properties
       # Generates an empty Mods Article (used when you call ModsArticle.new without passing in existing xml)
       def self.xml_template
@@ -53,24 +53,24 @@ describe "OM::XML::Accessors" do
               xml.machine
             }
           }
-        end  
-        return builder.doc
+        end
+        builder.doc
       end
     end
   end
-  
+
   before(:each) do
     @sample = RightsMDTest.from_xml(nil)
   end
-  
+
   describe "update_properties" do
     it "should update the declared properties" do
-      pending "nesting is too deep..."
-      @sample.retrieve(*[:edit_access, :machine, :person]).length.should == 0
-      @sample.update_properties([:edit_access, :machine, :person]=>"user id").should == {"edit_access_machine_person"=>{"-1"=>"user id"}}
-      @sample.retrieve(*[:edit_access, :machine, :person]).length.should == 1
-      @sample.retrieve(*[:edit_access, :machine, :person]).first.text.should == "user id"
+      skip "nesting is too deep..."
+      expect(@sample.retrieve(*[:edit_access, :machine, :person]).length).to eq(0)
+      expect(@sample.update_properties([:edit_access, :machine, :person]=>"user id")).to eq({"edit_access_machine_person"=>{"-1"=>"user id"}})
+      expect(@sample.retrieve(*[:edit_access, :machine, :person]).length).to eq(1)
+      expect(@sample.retrieve(*[:edit_access, :machine, :person]).first.text).to eq("user id")
     end
   end
-  
+
 end

data/spec/integration/selective_querying_spec.rb

@@ -83,7 +83,7 @@ describe "Selecting nodes based on (a) position in hierarchy and (b) attributes"
       [ 'inner_note_a',     %w(                    i3a i4a) ],
       [ 'inner_note_not_a', %w(              i1 i2        ) ],
     ]
-    tests.each { |meth, exp| @doc.send(meth).should == exp }
+    tests.each { |meth, exp| expect(@doc.send(meth)).to eq(exp) }
   end
 
 end

data/spec/integration/serialization_spec.rb

@@ -30,19 +30,19 @@ EOF
     end
     describe "reading  values" do
       it "should deserialize date" do
-        subject.my_date.should == [Date.parse('2012-10-30')]
+        expect(subject.my_date).to eq([Date.parse('2012-10-30')])
       end
       it "should deserialize ints" do
-        subject.my_int.should == [7]
+        expect(subject.my_int).to eq([7])
       end
       it "should deserialize boolean" do
-        subject.active.should == [true]
+        expect(subject.active).to eq([true])
       end
     end
     describe "Writing to xml" do
       it "should serialize date" do
         subject.my_date = [Date.parse('2012-09-22')]
-        subject.to_xml.should be_equivalent_to '<?xml version="1.0"?>
+        expect(subject.to_xml).to be_equivalent_to '<?xml version="1.0"?>
          <outer outerId="hypatia:outer" type="outer type">
            <my_date>2012-09-22</my_date>
            <my_int>7</my_int>
@@ -51,7 +51,7 @@ EOF
       end
       it "should serialize ints" do
         subject.my_int = [9]
-        subject.to_xml.should be_equivalent_to '<?xml version="1.0"?>
+        expect(subject.to_xml).to be_equivalent_to '<?xml version="1.0"?>
          <outer outerId="hypatia:outer" type="outer type">
            <my_date>2012-10-30</my_date>
            <my_int>9</my_int>
@@ -60,7 +60,7 @@ EOF
       end
       it "should serialize boolean" do
         subject.active = [false]
-        subject.to_xml.should be_equivalent_to '<?xml version="1.0"?>
+        expect(subject.to_xml).to be_equivalent_to '<?xml version="1.0"?>
          <outer outerId="hypatia:outer" type="outer type">
            <my_date>2012-10-30</my_date>
            <my_int>7</my_int>
@@ -82,19 +82,19 @@ EOF
     end
     describe "reading  values" do
       it "should deserialize date" do
-        subject.my_date.should == [nil]
+        expect(subject.my_date).to eq([nil])
       end
       it "should deserialize ints" do
-        subject.my_int.should == [nil]
+        expect(subject.my_int).to eq([nil])
       end
       it "should deserialize bools" do
-        subject.active.should == [false]
+        expect(subject.active).to eq([false])
       end
     end
     describe "Writing to xml" do
       it "should serialize date" do
         subject.my_date = [Date.parse('2012-09-22')]
-        subject.to_xml.should be_equivalent_to '<?xml version="1.0"?>
+        expect(subject.to_xml).to be_equivalent_to '<?xml version="1.0"?>
          <outer outerId="hypatia:outer" type="outer type">
            <my_date>2012-09-22</my_date>
            <my_int></my_int>
@@ -103,7 +103,7 @@ EOF
       end
       it "should serialize ints" do
         subject.my_int = [9]
-        subject.to_xml.should be_equivalent_to '<?xml version="1.0"?>
+        expect(subject.to_xml).to be_equivalent_to '<?xml version="1.0"?>
          <outer outerId="hypatia:outer" type="outer type">
            <my_date></my_date>
            <my_int>9</my_int>
@@ -112,7 +112,7 @@ EOF
       end
       it "should serialize booleans" do
         subject.active = [true]
-        subject.to_xml.should be_equivalent_to '<?xml version="1.0"?>
+        expect(subject.to_xml).to be_equivalent_to '<?xml version="1.0"?>
          <outer outerId="hypatia:outer" type="outer type">
            <my_date></my_date>
            <my_int></my_int>
@@ -124,7 +124,7 @@ EOF
         subject.my_int = [nil]
         subject.my_date = [nil]
         subject.active = [nil]
-        subject.to_xml.should be_equivalent_to '<?xml version="1.0"?>
+        expect(subject.to_xml).to be_equivalent_to '<?xml version="1.0"?>
          <outer outerId="hypatia:outer" type="outer type">
          </outer>'
       end

data/spec/integration/set_reentrant_terminology_spec.rb

@@ -21,7 +21,7 @@ describe "calling set_terminology more than once" do
     end
 
     it "can get foo" do
-      subject.foo.should == ['fooval']
+      expect(subject.foo).to eq(['fooval'])
     end
 
     it "cannot get bar" do
@@ -51,7 +51,7 @@ describe "calling set_terminology more than once" do
     end
 
     it "can now get bar" do
-      subject.bar.should == ['barval']
+      expect(subject.bar).to eq(['barval'])
     end
 
   end
@@ -80,11 +80,11 @@ describe "calling set_terminology more than once" do
     end
 
     it "can get foo" do
-      subject.foo.should == ['fooval']
+      expect(subject.foo).to eq(['fooval'])
     end
 
     it "can get bar" do
-      subject.bar.should == ['barval']
+      expect(subject.bar).to eq(['barval'])
     end
 
   end
@@ -100,7 +100,7 @@ describe "calling set_terminology more than once" do
         end
       end
 
-      class LocalReentrantTerminology 
+      class LocalReentrantTerminology
         include OM::XML::Document
         use_terminology(ReentrantTerminology)
         extend_terminology do |t|
@@ -122,11 +122,11 @@ describe "calling set_terminology more than once" do
     end
 
     it "can get foo" do
-      subject.foo.should == ['fooval']
+      expect(subject.foo).to eq(['fooval'])
     end
 
     it "can get bar" do
-      subject.bar.should == ['barval']
+      expect(subject.bar).to eq(['barval'])
     end
 
   end