om 1.8.0 → 1.8.1

data/spec/unit/term_xpath_generator_spec.rb

@@ -18,73 +18,71 @@ describe "OM::XML::TermXpathGeneratorSpec" do
   end
 
   before(:each) do
-    @test_term = OM::XML::Term.new(:terms_of_address, :path=>"namePart", :attributes=>{:type=>"termsOfAddress"})
+    @test_term                   = OM::XML::Term.new(:terms_of_address, :path=>"namePart", :attributes=>{:type=>"termsOfAddress"})
     @test_term_with_default_path = OM::XML::Term.new(:volume, :path=>"detail", :attributes=>{:type=>"volume"}, :default_content_path=>"number")
-    @test_role_text = OM::XML::Term.new(:role_text, :path=>"roleTerm", :attributes=>{:type=>"text"})
-    @test_lang_attribute = OM::XML::Term.new(:language, :path=>{:attribute=>"lang"})
-    @test_none_attribute_value = OM::XML::Term.new(:person_id, :path=>"namePart", :attributes=>{:type=>:none})
-
+    @test_role_text              = OM::XML::Term.new(:role_text, :path=>"roleTerm", :attributes=>{:type=>"text"})
+    @test_lang_attribute         = OM::XML::Term.new(:language, :path=>{:attribute=>"lang"})
+    @test_none_attribute_value   = OM::XML::Term.new(:person_id, :path=>"namePart", :attributes=>{:type=>:none})
   end
 
   it "should support terms that are pointers to attribute values" do
-    OM::XML::TermXpathGenerator.generate_xpath(@test_lang_attribute, :absolute).should == "//@lang"
-    OM::XML::TermXpathGenerator.generate_xpath(@test_lang_attribute, :relative).should == "@lang"
-    OM::XML::TermXpathGenerator.generate_xpath(@test_lang_attribute, :constrained).should == '//@lang[contains(., "#{constraint_value}")]'.gsub('"', '\"')
+    expect(OM::XML::TermXpathGenerator.generate_xpath(@test_lang_attribute, :absolute)).to eq("//@lang")
+    expect(OM::XML::TermXpathGenerator.generate_xpath(@test_lang_attribute, :relative)).to eq("@lang")
+    expect(OM::XML::TermXpathGenerator.generate_xpath(@test_lang_attribute, :constrained)).to eq('//@lang[contains(., "#{constraint_value}")]'.gsub('"', '\"'))
   end
 
   describe "generate_xpath" do
     it "should generate an xpath based on the given mapper and options" do
-      OM::XML::TermXpathGenerator.expects(:generate_absolute_xpath).with(@test_term)
+      expect(OM::XML::TermXpathGenerator).to receive(:generate_absolute_xpath).with(@test_term)
       OM::XML::TermXpathGenerator.generate_xpath(@test_term, :absolute)
 
-      OM::XML::TermXpathGenerator.expects(:generate_relative_xpath).with(@test_term)
+      expect(OM::XML::TermXpathGenerator).to receive(:generate_relative_xpath).with(@test_term)
       OM::XML::TermXpathGenerator.generate_xpath(@test_term, :relative)
 
-      OM::XML::TermXpathGenerator.expects(:generate_constrained_xpath).with(@test_term)
+      expect(OM::XML::TermXpathGenerator).to receive(:generate_constrained_xpath).with(@test_term)
       OM::XML::TermXpathGenerator.generate_xpath(@test_term, :constrained)
     end
   end
 
   describe "generate_relative_xpath" do
     it "should generate a relative xpath based on the given mapper" do
-      OM::XML::TermXpathGenerator.generate_relative_xpath(@test_term).should == 'namePart[@type="termsOfAddress"]'
+      expect(OM::XML::TermXpathGenerator.generate_relative_xpath(@test_term)).to eq('namePart[@type="termsOfAddress"]')
     end
     it "should support mappers without namespaces" do
       @test_term.namespace_prefix = nil
-      OM::XML::TermXpathGenerator.generate_relative_xpath(@test_term).should == 'namePart[@type="termsOfAddress"]'
+      expect(OM::XML::TermXpathGenerator.generate_relative_xpath(@test_term)).to eq('namePart[@type="termsOfAddress"]')
     end
     it "should not use a namespace for a path set to text() and should include normalize-space to ignore white space" do
       text_term = OM::XML::Term.new(:title_content, :path=>"text()")
-      OM::XML::TermXpathGenerator.generate_relative_xpath(text_term).should == 'text()[normalize-space(.)]'
+      expect(OM::XML::TermXpathGenerator.generate_relative_xpath(text_term)).to eq('text()[normalize-space(.)]')
     end
     it "should set a 'not' predicate if the attribute value is :none" do
-       OM::XML::TermXpathGenerator.generate_relative_xpath(@test_none_attribute_value).should == 'namePart[not(@type)]'
+       expect(OM::XML::TermXpathGenerator.generate_relative_xpath(@test_none_attribute_value)).to eq('namePart[not(@type)]')
     end
-
   end
 
   describe "generate_absolute_xpath" do
     it "should generate an absolute xpath based on the given mapper" do
-      OM::XML::TermXpathGenerator.generate_absolute_xpath(@test_term).should == '//namePart[@type="termsOfAddress"]'
+      expect(OM::XML::TermXpathGenerator.generate_absolute_xpath(@test_term)).to eq('//namePart[@type="termsOfAddress"]')
     end
     it "should prepend the xpath for any parent nodes" do
-      mock_parent_mapper = mock("Term", :xpath_absolute=>'//name[@type="conference"]/role')
-      @test_role_text.stubs(:parent).returns(mock_parent_mapper)
-      OM::XML::TermXpathGenerator.generate_absolute_xpath(@test_role_text).should == '//name[@type="conference"]/role/roleTerm[@type="text"]'
+      mock_parent_mapper = double("Term", :xpath_absolute=>'//name[@type="conference"]/role')
+      allow(@test_role_text).to receive(:parent).and_return(mock_parent_mapper)
+      expect(OM::XML::TermXpathGenerator.generate_absolute_xpath(@test_role_text)).to eq('//name[@type="conference"]/role/roleTerm[@type="text"]')
     end
   end
 
   describe "generate_constrained_xpath" do
     it "should generate a constrained xpath based on the given mapper" do
-      OM::XML::TermXpathGenerator.generate_constrained_xpath(@test_term).should == '//namePart[@type="termsOfAddress" and contains(., "#{constraint_value}")]'.gsub('"', '\"')
+      expect(OM::XML::TermXpathGenerator.generate_constrained_xpath(@test_term)).to eq('//namePart[@type="termsOfAddress" and contains(., "#{constraint_value}")]'.gsub('"', '\"'))
     end
   end
 
   it "should support mappers without namespaces" do
     @test_term.namespace_prefix = nil
-    OM::XML::TermXpathGenerator.generate_relative_xpath(@test_term).should == 'namePart[@type="termsOfAddress"]'
-    OM::XML::TermXpathGenerator.generate_absolute_xpath(@test_term).should == '//namePart[@type="termsOfAddress"]'
-    OM::XML::TermXpathGenerator.generate_constrained_xpath(@test_term).should == '//namePart[@type="termsOfAddress" and contains(., "#{constraint_value}")]'.gsub('"', '\"')
+    expect(OM::XML::TermXpathGenerator.generate_relative_xpath(@test_term)).to eq('namePart[@type="termsOfAddress"]')
+    expect(OM::XML::TermXpathGenerator.generate_absolute_xpath(@test_term)).to eq('//namePart[@type="termsOfAddress"]')
+    expect(OM::XML::TermXpathGenerator.generate_constrained_xpath(@test_term)).to eq('//namePart[@type="termsOfAddress" and contains(., "#{constraint_value}")]'.gsub('"', '\"'))
   end
 
   describe "generate_xpath_with_indexes" do
@@ -92,44 +90,40 @@ describe "OM::XML::TermXpathGeneratorSpec" do
       generated_xpath = OM::XML::TermXpathGenerator.generate_xpath_with_indexes( @sample_terminology, :person, {:first_name=>"Tim", :family_name=>"Berners-Lee"} )
       # expect an xpath that looks like this: '//oxns:name[@type="personal" and contains(oxns:namePart[@type="family"], "Berners-Lee") and contains(oxns:namePart[@type="given"], "Tim")]'
       # can't use string comparison because the contains functions can arrive in any order
-      generated_xpath.should match( /\/\/oxns:name\[@type=\"personal\".*and contains\(oxns:namePart\[@type=\"given\"\], \"Tim\"\).*\]/ )
-      generated_xpath.should match( /\/\/oxns:name\[@type=\"personal\".*and contains\(oxns:namePart\[@type=\"family\"\], \"Berners-Lee\"\).*\]/ )
+      expect(generated_xpath).to match( /\/\/oxns:name\[@type=\"personal\".*and contains\(oxns:namePart\[@type=\"given\"\], \"Tim\"\).*\]/ )
+      expect(generated_xpath).to match( /\/\/oxns:name\[@type=\"personal\".*and contains\(oxns:namePart\[@type=\"family\"\], \"Berners-Lee\"\).*\]/ )
     end
     it "should support xpath queries as argument" do
-      OM::XML::TermXpathGenerator.generate_xpath_with_indexes(@sample_terminology, '//oxns:name[@type="personal"][1]/oxns:namePart').should == '//oxns:name[@type="personal"][1]/oxns:namePart'
+      expect(OM::XML::TermXpathGenerator.generate_xpath_with_indexes(@sample_terminology, '//oxns:name[@type="personal"][1]/oxns:namePart')).to eq('//oxns:name[@type="personal"][1]/oxns:namePart')
     end
     it "should return the xpath of the terminology's root node if term pointer is nil" do
-      OM::XML::TermXpathGenerator.generate_xpath_with_indexes( @sample_terminology, nil ).should == @sample_terminology.root_terms.first.xpath
+      expect(OM::XML::TermXpathGenerator.generate_xpath_with_indexes( @sample_terminology, nil )).to eq(@sample_terminology.root_terms.first.xpath)
     end
     it "should return / if term pointer is nil and the terminology does not have a root term defined" do
-      OM::XML::TermXpathGenerator.generate_xpath_with_indexes( @rootless_terminology, nil ).should == "/"
+      expect(OM::XML::TermXpathGenerator.generate_xpath_with_indexes( @rootless_terminology, nil )).to eq("/")
     end
     it "should destringify term pointers before using them" do
-      generated_xpath = OM::XML::TermXpathGenerator.generate_xpath_with_indexes( @sample_terminology, {"person"=>"1"}, "first_name" ).should == '//oxns:name[@type="personal"][2]/oxns:namePart[@type="given"]'
+      generated_xpath = expect(OM::XML::TermXpathGenerator.generate_xpath_with_indexes( @sample_terminology, {"person"=>"1"}, "first_name" )).to eq('//oxns:name[@type="personal"][2]/oxns:namePart[@type="given"]')
       ### Last argument is a filter, we are passing no filters
-      @sample_terminology.xpath_with_indexes(:name, {:family_name=>1},{}).should == '//oxns:name/oxns:namePart[@type="family"][2]'
+      expect(@sample_terminology.xpath_with_indexes(:name, {:family_name=>1},{})).to eq('//oxns:name/oxns:namePart[@type="family"][2]')
     end
     it "should warn about indexes on a proxy" do
-      Logger.any_instance.expects(:warn).with("You attempted to call an index value of 1 on the term \":family_name\". However \":family_name\" is a proxy so we are ignoring the index. See https://jira.duraspace.org/browse/HYDRA-643")
-      @sample_terminology.xpath_with_indexes({:family_name=>1}).should == "//oxns:name/oxns:namePart[@type=\"family\"]"
+      expect_any_instance_of(Logger).to receive(:warn).with("You attempted to call an index value of 1 on the term \":family_name\". However \":family_name\" is a proxy so we are ignoring the index. See https://jira.duraspace.org/browse/HYDRA-643")
+      expect(@sample_terminology.xpath_with_indexes({:family_name=>1})).to eq("//oxns:name/oxns:namePart[@type=\"family\"]")
     end
   end
 
   it "should support mappers with default_content_path" do
-    pending "need to implement mapper_set first"
-    #@test_term_with_default_path = OM::XML::Term.new(:volume, :path=>"detail", :attributes=>{:type=>"volume"}, :default_content_path=>"number")
-
-    OM::XML::TermXpathGenerator.generate_relative_xpath(@test_term_with_default_path).should == 'oxns:detail[@type="volume"]'
-    OM::XML::TermXpathGenerator.generate_absolute_xpath(@test_term_with_default_path).should == '//oxns:detail[@type="volume"]'
-    OM::XML::TermXpathGenerator.generate_constrained_xpath(@test_term_with_default_path).should == '//oxns:detail[contains(oxns:number[@type="volume"], "#{constraint_value}")]'.gsub('"', '\"')
+    skip "need to implement mapper_set first"
+    # @test_term_with_default_path = OM::XML::Term.new(:volume, :path=>"detail", :attributes=>{:type=>"volume"}, :default_content_path=>"number")
+    expect(OM::XML::TermXpathGenerator.generate_relative_xpath(@test_term_with_default_path)).to eq('oxns:detail[@type="volume"]')
+    expect(OM::XML::TermXpathGenerator.generate_absolute_xpath(@test_term_with_default_path)).to eq('//oxns:detail[@type="volume"]')
+    expect(OM::XML::TermXpathGenerator.generate_constrained_xpath(@test_term_with_default_path)).to eq('//oxns:detail[contains(oxns:number[@type="volume"], "#{constraint_value}")]'.gsub('"', '\"'))
   end
 
   it "should default to using an inherited namspace prefix" do
-
     term = @sample_terminology.retrieve_term(:person, :first_name)
-    OM::XML::TermXpathGenerator.generate_absolute_xpath(term).should == "//oxns:name[@type=\"personal\"]/oxns:namePart[@type=\"given\"]"
-
-
+    expect(OM::XML::TermXpathGenerator.generate_absolute_xpath(term)).to eq("//oxns:name[@type=\"personal\"]/oxns:namePart[@type=\"given\"]")
   end
 
 end

data/spec/unit/terminology_builder_spec.rb

@@ -1,20 +1,20 @@
 require 'spec_helper'
 
 describe "OM::XML::Terminology::Builder" do
-  
+
     before(:each) do
       @test_builder = OM::XML::Terminology::Builder.new
-      
+
       @builder_with_block = OM::XML::Terminology::Builder.new do |t|
         t.root(:path=>"mods", :xmlns=>"http://www.loc.gov/mods/v3", :schema=>"http://www.loc.gov/standards/mods/v3/mods-3-2.xsd")
 
         t.title_info(:path=>"titleInfo") {
           t.main_title(:path=>"title", :label=>"title")
           t.language(:path=>{:attribute=>"lang"})
-        }          
+        }
         # t.title(:path=>"titleInfo", :default_content_path=>"title") {
         #   t.@language(:path=>{:attribute=>"lang"})
-        # }            
+        # }
         # This is a mods:name.  The underscore is purely to avoid namespace conflicts.
         t.name_ {
           # this is a namepart
@@ -29,7 +29,7 @@ describe "OM::XML::Terminology::Builder" do
           t.given_name(:path=>"namePart", :attributes=>{:type=>"given"}, :label=>"first name")
           t.terms_of_address(:path=>"namePart", :attributes=>{:type=>"termsOfAddress"})
         }
-        # lookup :person, :first_name        
+        # lookup :person, :first_name
         t.person(:ref=>:name, :attributes=>{:type=>"personal"})
 
         t.role {
@@ -61,144 +61,144 @@ describe "OM::XML::Terminology::Builder" do
       end
 
       # @test_full_terminology = @builder_with_block.build
-      
+
     end
-    
-    it "supports proxy terms at the root of the Terminology" do 
-      t_builder = OM::XML::Terminology::Builder.new do |t| 
-        t.root(:path=>"mods", :xmlns=>"http://www.loc.gov/mods/v3", :schema=>"http://www.loc.gov/standards/mods/v3/mods-3-2.xsd") 
-        t.title_info(:path=>"titleInfo") { 
-          t.main_title(:path=>"title", :label=>"title") 
-          t.language(:path=>{:attribute=>"lang"}) 
-        } 
-        t.title(:proxy=>[:title_info, :main_title], :index_as =>[:facetable, :not_searchable]) 
-      end 
-
-      terminology = t_builder.build 
-      terminology.retrieve_term(:title).should be_kind_of OM::XML::NamedTermProxy
-      terminology.retrieve_term(:title).index_as.should == [:facetable, :not_searchable]
-      terminology.retrieve_term(:title_info, :main_title).index_as.should == []
-      terminology.xpath_for(:title).should == '//oxns:titleInfo/oxns:title'
-      terminology.xpath_with_indexes({:title=>0}).should == "//oxns:titleInfo/oxns:title"
+
+    it "supports proxy terms at the root of the Terminology" do
+      t_builder = OM::XML::Terminology::Builder.new do |t|
+        t.root(:path=>"mods", :xmlns=>"http://www.loc.gov/mods/v3", :schema=>"http://www.loc.gov/standards/mods/v3/mods-3-2.xsd")
+        t.title_info(:path=>"titleInfo") {
+          t.main_title(:path=>"title", :label=>"title")
+          t.language(:path=>{:attribute=>"lang"})
+        }
+        t.title(:proxy=>[:title_info, :main_title], :index_as =>[:facetable, :not_searchable])
+      end
+
+      terminology = t_builder.build
+      expect(terminology.retrieve_term(:title)).to be_kind_of OM::XML::NamedTermProxy
+      expect(terminology.retrieve_term(:title).index_as).to eq([:facetable, :not_searchable])
+      expect(terminology.retrieve_term(:title_info, :main_title).index_as).to eq([])
+      expect(terminology.xpath_for(:title)).to eq('//oxns:titleInfo/oxns:title')
+      expect(terminology.xpath_with_indexes({:title=>0})).to eq("//oxns:titleInfo/oxns:title")
       # @builder_with_block.build.xpath_for_pointer(:issue).should == '//oxns:part'
       # terminology.xpath_for_pointer(:title).should == '//oxns:titleInfo/oxns:title'
     end
-    
+
     describe '#new' do
       it "should return an instance of OM::XML::Terminology::Builder" do
-        OM::XML::Terminology::Builder.new.should be_instance_of OM::XML::Terminology::Builder
+        expect(OM::XML::Terminology::Builder.new).to be_instance_of OM::XML::Terminology::Builder
       end
       it "should process the input block, creating a new Term Builder for each entry and its children" do
         expected_root_terms = [:mods, :title_info, :issue, :person, :name, :journal, :role]
         expected_root_terms.each do |name|
-          @builder_with_block.term_builders.should have_key(name)
+          expect(@builder_with_block.term_builders).to have_key(name)
         end
-        @builder_with_block.term_builders.length.should == expected_root_terms.length
-        
-        @builder_with_block.term_builders[:journal].should be_instance_of OM::XML::Term::Builder
-        @builder_with_block.term_builders[:journal].settings[:path].should == "relatedItem"
-        @builder_with_block.term_builders[:journal].settings[:attributes].should == {:type=>"host"}
-
-        @builder_with_block.term_builders[:journal].children[:issn].should be_instance_of OM::XML::Term::Builder
-        @builder_with_block.term_builders[:journal].children[:issn].settings[:path].should == "identifier"
-        @builder_with_block.term_builders[:journal].children[:issn].settings[:attributes].should == {:type=>"issn"}
+        expect(@builder_with_block.term_builders.length).to eq(expected_root_terms.length)
+
+        expect(@builder_with_block.term_builders[:journal]).to be_instance_of OM::XML::Term::Builder
+        expect(@builder_with_block.term_builders[:journal].settings[:path]).to eq("relatedItem")
+        expect(@builder_with_block.term_builders[:journal].settings[:attributes]).to eq({:type=>"host"})
+
+        expect(@builder_with_block.term_builders[:journal].children[:issn]).to be_instance_of OM::XML::Term::Builder
+        expect(@builder_with_block.term_builders[:journal].children[:issn].settings[:path]).to eq("identifier")
+        expect(@builder_with_block.term_builders[:journal].children[:issn].settings[:attributes]).to eq({:type=>"issn"})
       end
       it "should clip the underscore off the end of any Term names" do
-        @builder_with_block.term_builders[:name].should be_instance_of OM::XML::Term::Builder
-        @builder_with_block.term_builders[:name].name.should == :name
+        expect(@builder_with_block.term_builders[:name]).to be_instance_of OM::XML::Term::Builder
+        expect(@builder_with_block.term_builders[:name].name).to eq(:name)
 
-        @builder_with_block.term_builders[:name].children[:date].should be_instance_of OM::XML::Term::Builder
-        @builder_with_block.term_builders[:name].children[:date].settings[:path].should == "namePart"
-        @builder_with_block.term_builders[:name].children[:date].settings[:attributes].should == {:type=>"date"}
+        expect(@builder_with_block.term_builders[:name].children[:date]).to be_instance_of OM::XML::Term::Builder
+        expect(@builder_with_block.term_builders[:name].children[:date].settings[:path]).to eq("namePart")
+        expect(@builder_with_block.term_builders[:name].children[:date].settings[:attributes]).to eq({:type=>"date"})
       end
     end
-    
+
     describe '#from_xml' do
       it "should let you load mappings from an xml file" do
-        pending
+        skip
         vocab = OM::XML::Terminology.from_xml( fixture("sample_mappings.xml") )
-        vocab.should be_instance_of OM::XML::Terminology
-        vocab.mappers.should == {}
+        expect(vocab).to be_instance_of OM::XML::Terminology
+        expect(vocab.mappers).to eq({})
       end
     end
-    
+
     describe ".retrieve_term_builder" do
       it "should support looking up Term Builders by pointer" do
         expected = @builder_with_block.term_builders[:name].children[:date]
-        @builder_with_block.retrieve_term_builder(:name, :date).should == expected
+        expect(@builder_with_block.retrieve_term_builder(:name, :date)).to eq(expected)
       end
     end
-    
+
     describe "build" do
       it "should generate the new Terminology, calling .build on its Term builders"
       it "should resolve :refs" do
-        @builder_with_block.retrieve_term_builder(:name, :role).settings[:ref].should == [:role]
-        @builder_with_block.retrieve_term_builder(:role).children[:text].should be_instance_of OM::XML::Term::Builder
-        
+        expect(@builder_with_block.retrieve_term_builder(:name, :role).settings[:ref]).to eq([:role])
+        expect(@builder_with_block.retrieve_term_builder(:role).children[:text]).to be_instance_of OM::XML::Term::Builder
+
         built_terminology = @builder_with_block.build
-        
-        built_terminology.retrieve_term(:name, :role, :text).should be_instance_of OM::XML::Term
-        built_terminology.retrieve_term(:name, :role, :text).path.should == "roleTerm"
-        built_terminology.retrieve_term(:name, :role, :text).attributes.should == {:type=>"text"}
+
+        expect(built_terminology.retrieve_term(:name, :role, :text)).to be_instance_of OM::XML::Term
+        expect(built_terminology.retrieve_term(:name, :role, :text).path).to eq("roleTerm")
+        expect(built_terminology.retrieve_term(:name, :role, :text).attributes).to eq({:type=>"text"})
       end
       it "should put copies of the entire terminology under any root terms" do
-        @builder_with_block.root_term_builders.should include(@builder_with_block.retrieve_term_builder(:mods))
-        
+        expect(@builder_with_block.root_term_builders).to include(@builder_with_block.retrieve_term_builder(:mods))
+
         built_terminology = @builder_with_block.build
         expected_keys = [:title_info, :issue, :person, :name, :journal, :role]
-        
-        built_terminology.retrieve_term(:mods).children.length.should == expected_keys.length
+
+        expect(built_terminology.retrieve_term(:mods).children.length).to eq(expected_keys.length)
         expected_keys.each do |key|
-          built_terminology.retrieve_term(:mods).children.keys.should include(key)
+          expect(built_terminology.retrieve_term(:mods).children.keys).to include(key)
         end
-        built_terminology.retrieve_term(:mods, :name, :role, :text).should be_instance_of OM::XML::Term
-        built_terminology.retrieve_term(:mods, :person, :role, :text).should be_instance_of OM::XML::Term
+        expect(built_terminology.retrieve_term(:mods, :name, :role, :text)).to be_instance_of OM::XML::Term
+        expect(built_terminology.retrieve_term(:mods, :person, :role, :text)).to be_instance_of OM::XML::Term
 
       end
     end
-    
+
     describe '.insert_term' do
       it "should create a new OM::XML::Term::Builder and insert it into the class mappings hash" do
-        pending
-        
-        result = @test_builder.insert_mapper(:name_, :namePart).index_as([:facetable, :searchable, :sortable, :displayable]).required(true).type(:text)  
-        @test_builder.mapper_builders(:name_, :namePart).should == result
-        result.should be_instance_of OM::XML::Mapper::Builder
+        skip
+
+        result = @test_builder.insert_mapper(:name_, :namePart).index_as([:facetable, :searchable, :sortable, :displayable]).required(true).type(:text)
+        expect(@test_builder.mapper_builders(:name_, :namePart)).to eq(result)
+        expect(result).to be_instance_of OM::XML::Mapper::Builder
       end
     end
-    
+
     describe ".root" do
       it "should accept options for the root node, such as namespace(s)  and schema and those values should impact the resulting Terminology" do
         root_term_builder = @test_builder.root(:path=>"mods", :xmlns => 'one:two', 'xmlns:foo' => 'bar', :schema=>"http://www.loc.gov/standards/mods/v3/mods-3-2.xsd")
-        root_term_builder.settings[:is_root_term].should == true
-        
-        @test_builder.schema.should == "http://www.loc.gov/standards/mods/v3/mods-3-2.xsd"
-        @test_builder.namespaces.should == { "oxns"=>"one:two", 'xmlns' => 'one:two', 'xmlns:foo' => 'bar' }
-        @test_builder.term_builders[:mods].should == root_term_builder      
-        
+        expect(root_term_builder.settings[:is_root_term]).to eq(true)
+
+        expect(@test_builder.schema).to eq("http://www.loc.gov/standards/mods/v3/mods-3-2.xsd")
+        expect(@test_builder.namespaces).to eq({ "oxns"=>"one:two", 'xmlns' => 'one:two', 'xmlns:foo' => 'bar' })
+        expect(@test_builder.term_builders[:mods]).to eq(root_term_builder)
+
         terminology = @test_builder.build
-        terminology.schema.should == "http://www.loc.gov/standards/mods/v3/mods-3-2.xsd"
-        terminology.namespaces.should == { "oxns"=>"one:two", 'xmlns' => 'one:two', 'xmlns:foo' => 'bar' }
+        expect(terminology.schema).to eq("http://www.loc.gov/standards/mods/v3/mods-3-2.xsd")
+        expect(terminology.namespaces).to eq({ "oxns"=>"one:two", 'xmlns' => 'one:two', 'xmlns:foo' => 'bar' })
       end
       it "should create an explicit term correspoinding to the root node and pass any additional settings into that term" do
         @test_builder.root(:path=>"fwoop", :xmlns => 'one:two', 'xmlns:foo' => 'bar', :index_as=>[:not_searchable], :namespace_prefix=>"foox")
         terminology = @test_builder.build
         term = terminology.retrieve_term(:fwoop)
-        term.should be_instance_of OM::XML::Term
-        term.is_root_term?.should == true
-        term.index_as.should == [:not_searchable]        
-        term.namespace_prefix.should == "foox"   
+        expect(term).to be_instance_of OM::XML::Term
+        expect(term.is_root_term?).to eq(true)
+        expect(term.index_as).to eq([:not_searchable])
+        expect(term.namespace_prefix).to eq("foox")
       end
       it "should work within a builder block" do
-        @builder_with_block.term_builders[:mods].settings[:is_root_term].should == true
+        expect(@builder_with_block.term_builders[:mods].settings[:is_root_term]).to eq(true)
       end
     end
-    
+
     describe ".root_term_builders" do
       it "should return the terms that have been marked root" do
-        @builder_with_block.root_term_builders.length.should == 1
-        @builder_with_block.root_term_builders.first.should == @builder_with_block.term_builders[:mods]
+        expect(@builder_with_block.root_term_builders.length).to eq(1)
+        expect(@builder_with_block.root_term_builders.first).to eq(@builder_with_block.term_builders[:mods])
       end
     end
-    
+
 end

data/spec/unit/terminology_spec.rb

@@ -89,162 +89,162 @@ describe "OM::XML::Terminology" do
 
   describe "namespaceless terminologies" do
     it "should generate xpath queries without namespaces" do
-      @namespaceless_terminology.xpath_for(:to).should == "//to"
-      @namespaceless_terminology.xpath_for(:note, :from).should == "//note/from"
+      expect(@namespaceless_terminology.xpath_for(:to)).to eq("//to")
+      expect(@namespaceless_terminology.xpath_for(:note, :from)).to eq("//note/from")
     end
 
     it "should work with xml documents that have no namespaces" do
-      @namespaceless_doc.from.first.should == "Jani"
-      @namespaceless_doc.to.should == ["Tove"]
+      expect(@namespaceless_doc.from.first).to eq("Jani")
+      expect(@namespaceless_doc.to).to eq(["Tove"])
     end
   end
 
   describe "basics" do
 
     it "constructs xpath queries for finding properties" do
-      @test_full_terminology.retrieve_term(:name).xpath.should == '//oxns:name'
-      @test_full_terminology.retrieve_term(:name).xpath_relative.should == 'oxns:name'
+      expect(@test_full_terminology.retrieve_term(:name).xpath).to eq('//oxns:name')
+      expect(@test_full_terminology.retrieve_term(:name).xpath_relative).to eq('oxns:name')
 
-      @test_full_terminology.retrieve_term(:person).xpath.should == '//oxns:name[@type="personal"]'
-      @test_full_terminology.retrieve_term(:person).xpath_relative.should == 'oxns:name[@type="personal"]'
-      @test_full_terminology.retrieve_term(:person, :person_id).xpath_relative.should == 'oxns:namePart[not(@type)]'
+      expect(@test_full_terminology.retrieve_term(:person).xpath).to eq('//oxns:name[@type="personal"]')
+      expect(@test_full_terminology.retrieve_term(:person).xpath_relative).to eq('oxns:name[@type="personal"]')
+      expect(@test_full_terminology.retrieve_term(:person, :person_id).xpath_relative).to eq('oxns:namePart[not(@type)]')
     end
 
     it "should expand proxy and get sub terms" do
-      @test_full_terminology.retrieve_node(:title, :main_title_lang).xpath.should == '//oxns:titleInfo/oxns:title/@xml:lang'
+      expect(@test_full_terminology.retrieve_node(:title, :main_title_lang).xpath).to eq('//oxns:titleInfo/oxns:title/@xml:lang')
       ### retrieve_term() will not cross proxies
-      @test_full_terminology.retrieve_term(:title_info, :main_title, :main_title_lang).xpath.should == '//oxns:titleInfo/oxns:title/@xml:lang'
+      expect(@test_full_terminology.retrieve_term(:title_info, :main_title, :main_title_lang).xpath).to eq('//oxns:titleInfo/oxns:title/@xml:lang')
     end
 
     it "constructs templates for value-driven searches" do
-      @test_full_terminology.retrieve_term(:name).xpath_constrained.should == '//oxns:name[contains(., "#{constraint_value}")]'.gsub('"', '\"')
-      @test_full_terminology.retrieve_term(:person).xpath_constrained.should == '//oxns:name[@type="personal" and contains(., "#{constraint_value}")]'.gsub('"', '\"')
+      expect(@test_full_terminology.retrieve_term(:name).xpath_constrained).to eq('//oxns:name[contains(., "#{constraint_value}")]'.gsub('"', '\"'))
+      expect(@test_full_terminology.retrieve_term(:person).xpath_constrained).to eq('//oxns:name[@type="personal" and contains(., "#{constraint_value}")]'.gsub('"', '\"'))
 
       # Example of how you could use these templates:
       constraint_value = "SAMPLE CONSTRAINT VALUE"
       constrained_query = eval( '"' + @test_full_terminology.retrieve_term(:person).xpath_constrained + '"' )
-      constrained_query.should == '//oxns:name[@type="personal" and contains(., "SAMPLE CONSTRAINT VALUE")]'
+      expect(constrained_query).to eq('//oxns:name[@type="personal" and contains(., "SAMPLE CONSTRAINT VALUE")]')
     end
 
     it "constructs xpath queries & templates for nested terms" do
       name_date_term = @test_full_terminology.retrieve_term(:name, :date)
-      name_date_term.xpath.should == '//oxns:name/oxns:namePart[@type="date"]'
-      name_date_term.xpath_relative.should == 'oxns:namePart[@type="date"]'
-      name_date_term.xpath_constrained.should == '//oxns:name/oxns:namePart[@type="date" and contains(., "#{constraint_value}")]'.gsub('"', '\"')
+      expect(name_date_term.xpath).to eq('//oxns:name/oxns:namePart[@type="date"]')
+      expect(name_date_term.xpath_relative).to eq('oxns:namePart[@type="date"]')
+      expect(name_date_term.xpath_constrained).to eq('//oxns:name/oxns:namePart[@type="date" and contains(., "#{constraint_value}")]'.gsub('"', '\"'))
       # name_date_term.xpath_constrained.should == '//oxns:name[contains(oxns:namePart[@type="date"], "#{constraint_value}")]'.gsub('"', '\"')
 
       person_date_term = @test_full_terminology.retrieve_term(:person, :date)
-      person_date_term.xpath.should == '//oxns:name[@type="personal"]/oxns:namePart[@type="date"]'
-      person_date_term.xpath_relative.should == 'oxns:namePart[@type="date"]'
-      person_date_term.xpath_constrained.should == '//oxns:name[@type="personal"]/oxns:namePart[@type="date" and contains(., "#{constraint_value}")]'.gsub('"', '\"')
+      expect(person_date_term.xpath).to eq('//oxns:name[@type="personal"]/oxns:namePart[@type="date"]')
+      expect(person_date_term.xpath_relative).to eq('oxns:namePart[@type="date"]')
+      expect(person_date_term.xpath_constrained).to eq('//oxns:name[@type="personal"]/oxns:namePart[@type="date" and contains(., "#{constraint_value}")]'.gsub('"', '\"'))
       # person_date_term.xpath_constrained.should == '//oxns:name[@type="personal" and contains(oxns:namePart[@type="date"], "#{constraint_value}")]'.gsub('"', '\"')
     end
 
     it "supports subelements that are specified using a :ref" do
       role_term = @test_full_terminology.retrieve_term(:name, :role)
-      role_term.xpath.should == '//oxns:name/oxns:role'
-      role_term.xpath_relative.should == 'oxns:role'
-      role_term.xpath_constrained.should == '//oxns:name/oxns:role[contains(., "#{constraint_value}")]'.gsub('"', '\"')
+      expect(role_term.xpath).to eq('//oxns:name/oxns:role')
+      expect(role_term.xpath_relative).to eq('oxns:role')
+      expect(role_term.xpath_constrained).to eq('//oxns:name/oxns:role[contains(., "#{constraint_value}")]'.gsub('"', '\"'))
       # role_term.xpath_constrained.should == '//oxns:name[contains(oxns:role/oxns:roleTerm, "#{constraint_value}")]'.gsub('"', '\"')
     end
 
     describe "treating attributes as properties" do
-      it "should build correct xpath" do    
+      it "should build correct xpath" do
         language_term = @test_full_terminology.retrieve_term(:title_info, :language)
-        language_term.xpath.should == '//oxns:titleInfo/@lang'
-        language_term.xpath_relative.should == '@lang'
-        language_term.xpath_constrained.should == '//oxns:titleInfo/@lang[contains(., "#{constraint_value}")]'.gsub('"', '\"')
+        expect(language_term.xpath).to eq('//oxns:titleInfo/@lang')
+        expect(language_term.xpath_relative).to eq('@lang')
+        expect(language_term.xpath_constrained).to eq('//oxns:titleInfo/@lang[contains(., "#{constraint_value}")]'.gsub('"', '\"'))
       end
     end
 
     it "should support deep nesting of properties" do
       volume_term = @test_full_terminology.retrieve_term(:journal, :issue, :volume)
-      volume_term.xpath.should == "//oxns:relatedItem[@type=\"host\"]/oxns:part/oxns:detail[@type=\"volume\"]"
-      volume_term.xpath_relative.should == "oxns:detail[@type=\"volume\"]"
+      expect(volume_term.xpath).to eq("//oxns:relatedItem[@type=\"host\"]/oxns:part/oxns:detail[@type=\"volume\"]")
+      expect(volume_term.xpath_relative).to eq("oxns:detail[@type=\"volume\"]")
       # volume_term.xpath_constrained.should == "//oxns:part[contains(oxns:detail[@type=\\\"volume\\\"], \\\"\#{constraint_value}\\\")]"
-      volume_term.xpath_constrained.should == '//oxns:relatedItem[@type="host"]/oxns:part/oxns:detail[@type="volume" and contains(oxns:number, "#{constraint_value}")]'.gsub('"', '\"')
+      expect(volume_term.xpath_constrained).to eq('//oxns:relatedItem[@type="host"]/oxns:part/oxns:detail[@type="volume" and contains(oxns:number, "#{constraint_value}")]'.gsub('"', '\"'))
     end
 
     it "should not overwrite default property info when adding a variant property" do
       name_term = @test_full_terminology.retrieve_term(:name)
       person_term = @test_full_terminology.retrieve_term(:person)
 
-      name_term.should_not equal(person_term)
-      name_term.xpath.should_not equal(person_term.xpath)
-      name_term.children.should_not equal(person_term.children)
-      name_term.children[:date].xpath_constrained.should_not equal(person_term.children[:date].xpath_constrained)
+      expect(name_term).not_to equal(person_term)
+      expect(name_term.xpath).not_to equal(person_term.xpath)
+      expect(name_term.children).not_to equal(person_term.children)
+      expect(name_term.children[:date].xpath_constrained).not_to equal(person_term.children[:date].xpath_constrained)
     end
 
   end
 
   describe '#from_xml' do
     it "should let you load mappings from an xml file" do
-      pending
+      skip
       vocab = OM::XML::Terminology.from_xml( fixture("sample_mappings.xml") )
-      vocab.should be_instance_of OM::XML::Terminology
-      vocab.mappers.should == {}
+      expect(vocab).to be_instance_of OM::XML::Terminology
+      expect(vocab.mappers).to eq({})
     end
   end
 
   describe '#to_xml' do
     it "should let you serialize mappings to an xml document" do
-      pending
-      TerminologyTest.to_xml.should == ""
+      skip
+      expect(TerminologyTest.to_xml).to eq("")
     end
   end
 
   describe ".has_term?" do
     it "should return true if the specified term does exist in the terminology" do
-      @test_full_terminology.has_term?(:journal,:issue,:end_page).should be_true
+      expect(@test_full_terminology.has_term?(:journal,:issue,:end_page)).to be_truthy
     end
     it "should support term_pointers with array indexes in them (ignoring the indexes)" do
-      @test_full_terminology.has_term?(:title_info, :main_title).should be_true
-      @test_full_terminology.has_term?({:title_info=>"0"}, :main_title).should be_true
+      expect(@test_full_terminology.has_term?(:title_info, :main_title)).to be_truthy
+      expect(@test_full_terminology.has_term?({:title_info=>"0"}, :main_title)).to be_truthy
     end
     it "should return false if the specified term does not exist in the terminology" do
-      @test_full_terminology.has_term?(:name, :date, :nonexistentTerm, :anotherTermName).should be_false
+      expect(@test_full_terminology.has_term?(:name, :date, :nonexistentTerm, :anotherTermName)).to be_falsey
     end
   end
 
   describe ".retrieve_term" do
     it "should return the mapper identified by the given pointer" do
       term = @test_terminology.retrieve_term(:name, :namePart)
-      term.should == @test_terminology.terms[:name].children[:namePart]
-      term.should == @test_child_term
+      expect(term).to eq(@test_terminology.terms[:name].children[:namePart])
+      expect(term).to eq(@test_child_term)
     end
     it "should build complete terminologies" do
-      @test_full_terminology.retrieve_term(:name, :date).should be_instance_of OM::XML::Term
-      @test_full_terminology.retrieve_term(:name, :date).path.should == 'namePart'
-      @test_full_terminology.retrieve_term(:name, :date).attributes.should == {:type=>"date"}
-      @test_full_terminology.retrieve_term(:name, :affiliation).path.should == 'affiliation'
-      @test_full_terminology.retrieve_term(:name, :date).xpath.should == '//oxns:name/oxns:namePart[@type="date"]'
+      expect(@test_full_terminology.retrieve_term(:name, :date)).to be_instance_of OM::XML::Term
+      expect(@test_full_terminology.retrieve_term(:name, :date).path).to eq('namePart')
+      expect(@test_full_terminology.retrieve_term(:name, :date).attributes).to eq({:type=>"date"})
+      expect(@test_full_terminology.retrieve_term(:name, :affiliation).path).to eq('affiliation')
+      expect(@test_full_terminology.retrieve_term(:name, :date).xpath).to eq('//oxns:name/oxns:namePart[@type="date"]')
     end
     it "should support looking up variant Terms" do
-      @test_full_terminology.retrieve_term(:person).path.should == 'name'
-      @test_full_terminology.retrieve_term(:person).attributes.should == {:type=>"personal"}
-      @test_full_terminology.retrieve_term(:person, :affiliation).path.should == 'affiliation'
-      @test_full_terminology.retrieve_term(:person, :date).xpath.should == '//oxns:name[@type="personal"]/oxns:namePart[@type="date"]'
+      expect(@test_full_terminology.retrieve_term(:person).path).to eq('name')
+      expect(@test_full_terminology.retrieve_term(:person).attributes).to eq({:type=>"personal"})
+      expect(@test_full_terminology.retrieve_term(:person, :affiliation).path).to eq('affiliation')
+      expect(@test_full_terminology.retrieve_term(:person, :date).xpath).to eq('//oxns:name[@type="personal"]/oxns:namePart[@type="date"]')
     end
     it "should support including root terms in pointer" do
-      @test_full_terminology.retrieve_term(:mods).should be_instance_of OM::XML::Term
-      @test_full_terminology.retrieve_term(:mods, :name, :date).should be_instance_of OM::XML::Term
-      @test_full_terminology.retrieve_term(:mods, :name, :date).path.should == 'namePart'
-      @test_full_terminology.retrieve_term(:mods, :name, :date).attributes.should == {:type=>"date"}
-      @test_full_terminology.retrieve_term(:mods, :name, :date).xpath.should == '//oxns:mods/oxns:name/oxns:namePart[@type="date"]'
+      expect(@test_full_terminology.retrieve_term(:mods)).to be_instance_of OM::XML::Term
+      expect(@test_full_terminology.retrieve_term(:mods, :name, :date)).to be_instance_of OM::XML::Term
+      expect(@test_full_terminology.retrieve_term(:mods, :name, :date).path).to eq('namePart')
+      expect(@test_full_terminology.retrieve_term(:mods, :name, :date).attributes).to eq({:type=>"date"})
+      expect(@test_full_terminology.retrieve_term(:mods, :name, :date).xpath).to eq('//oxns:mods/oxns:name/oxns:namePart[@type="date"]')
     end
 
     it "should raise an informative error if the desired Term doesn't exist" do
-      lambda { @test_full_terminology.retrieve_term(:name, :date, :nonexistentTerm, :anotherTermName) }.should raise_error(OM::XML::Terminology::BadPointerError, "You attempted to retrieve a Term using this pointer: [:name, :date, :nonexistentTerm, :anotherTermName] but no Term exists at that location. Everything is fine until \":nonexistentTerm\", which doesn't exist.")
+      expect { @test_full_terminology.retrieve_term(:name, :date, :nonexistentTerm, :anotherTermName) }.to raise_error(OM::XML::Terminology::BadPointerError, "You attempted to retrieve a Term using this pointer: [:name, :date, :nonexistentTerm, :anotherTermName] but no Term exists at that location. Everything is fine until \":nonexistentTerm\", which doesn't exist.")
     end
   end
 
   describe ".term_xpath" do
     it "should insert calls to xpath array lookup into parent xpaths if parents argument is provided" do
-      pending
+      skip
       # conference_mapper = TerminologyTest.retrieve_mapper(:conference)
       # role_mapper =  TerminologyTest.retrieve_mapper(:conference, :role)
       # text_mapper = TerminologyTest.retrieve_mapper(:conference, :role, :text)
-      TerminologyTest.term_xpath({:conference=>0}, {:role=>1}, :text ).should == '//oxns:name[@type="conference"][1]/oxns:role[2]/oxns:roleTerm[@type="text"]'
+      expect(TerminologyTest.term_xpath({:conference=>0}, {:role=>1}, :text )).to eq('//oxns:name[@type="conference"][1]/oxns:role[2]/oxns:roleTerm[@type="text"]')
       # OM::XML::TermXpathGenerator.expects(:generate_absolute_xpath).with({conference_mapper=>0}, {role_mapper=>1}, text_mapper)
     end
   end
@@ -252,72 +252,72 @@ describe "OM::XML::Terminology" do
   describe ".xpath_for" do
 
     it "should retrieve the generated xpath query to match your desires" do
-      @test_full_terminology.xpath_for(:person).should == '//oxns:name[@type="personal"]'
+      expect(@test_full_terminology.xpath_for(:person)).to eq('//oxns:name[@type="personal"]')
 
-      @test_full_terminology.xpath_for(:person, "Beethoven, Ludwig van").should == '//oxns:name[@type="personal" and contains(., "Beethoven, Ludwig van")]'
+      expect(@test_full_terminology.xpath_for(:person, "Beethoven, Ludwig van")).to eq('//oxns:name[@type="personal" and contains(., "Beethoven, Ludwig van")]')
 
-      @test_full_terminology.xpath_for(:person, :date).should == '//oxns:name[@type="personal"]/oxns:namePart[@type="date"]'
+      expect(@test_full_terminology.xpath_for(:person, :date)).to eq('//oxns:name[@type="personal"]/oxns:namePart[@type="date"]')
 
-      @test_full_terminology.xpath_for(:person, :date, "2010").should == '//oxns:name[@type="personal"]/oxns:namePart[@type="date" and contains(., "2010")]'
+      expect(@test_full_terminology.xpath_for(:person, :date, "2010")).to eq('//oxns:name[@type="personal"]/oxns:namePart[@type="date" and contains(., "2010")]')
 
-      @test_full_terminology.xpath_for(:person, :person_id).should == '//oxns:name[@type="personal"]/oxns:namePart[not(@type)]'
+      expect(@test_full_terminology.xpath_for(:person, :person_id)).to eq('//oxns:name[@type="personal"]/oxns:namePart[not(@type)]')
 
     end
 
     it "should support including root terms in term pointer" do
-      @test_full_terminology.xpath_for(:mods, :person).should == '//oxns:mods/oxns:name[@type="personal"]'
-      @test_full_terminology.xpath_for(:mods, :person, "Beethoven, Ludwig van").should == '//oxns:mods/oxns:name[@type="personal" and contains(., "Beethoven, Ludwig van")]'
+      expect(@test_full_terminology.xpath_for(:mods, :person)).to eq('//oxns:mods/oxns:name[@type="personal"]')
+      expect(@test_full_terminology.xpath_for(:mods, :person, "Beethoven, Ludwig van")).to eq('//oxns:mods/oxns:name[@type="personal" and contains(., "Beethoven, Ludwig van")]')
     end
 
     it "should support queries with complex constraints" do
-      pending
-      @test_full_terminology.xpath_for(:person, {:date=>"2010"}).should == '//oxns:name[@type="personal" and contains(oxns:namePart[@type="date"], "2010")]'
+      skip
+      expect(@test_full_terminology.xpath_for(:person, {:date=>"2010"})).to eq('//oxns:name[@type="personal" and contains(oxns:namePart[@type="date"], "2010")]')
     end
 
     it "should support queries with multiple complex constraints" do
-      pending
-      @test_full_terminology.xpath_for(:person, {:role=>"donor", :last_name=>"Rockefeller"}).should == '//oxns:name[@type="personal" and contains(oxns:role/oxns:roleTerm, "donor") and contains(oxns:namePart[@type="family"], "Rockefeller")]'
+      skip
+      expect(@test_full_terminology.xpath_for(:person, {:role=>"donor", :last_name=>"Rockefeller"})).to eq('//oxns:name[@type="personal" and contains(oxns:role/oxns:roleTerm, "donor") and contains(oxns:namePart[@type="family"], "Rockefeller")]')
     end
 
     it "should parrot any strings back to you (in case you already have an xpath query)" do
-      @test_full_terminology.xpath_for('//oxns:name[@type="personal"]/oxns:namePart[@type="date"]').should == '//oxns:name[@type="personal"]/oxns:namePart[@type="date"]'
+      expect(@test_full_terminology.xpath_for('//oxns:name[@type="personal"]/oxns:namePart[@type="date"]')).to eq('//oxns:name[@type="personal"]/oxns:namePart[@type="date"]')
     end
 
     it "should traverse named term proxies transparently" do
       proxied_xpath = @test_full_terminology.xpath_for(:journal, :issue, :pages, :start)
-      @test_full_terminology.xpath_for( :journal, :issue, :start_page ).should == proxied_xpath
+      expect(@test_full_terminology.xpath_for( :journal, :issue, :start_page )).to eq(proxied_xpath)
     end
 
   end
 
   describe ".xpath_with_indexes" do
     it "should return the xpath given in the call to #accessor" do
-      @test_full_terminology.xpath_with_indexes( :title_info ).should == '//oxns:titleInfo'
+      expect(@test_full_terminology.xpath_with_indexes( :title_info )).to eq('//oxns:titleInfo')
     end
     it "should support xpath queries as argument" do
-      @test_full_terminology.xpath_with_indexes('//oxns:name[@type="personal"][1]/oxns:namePart').should == '//oxns:name[@type="personal"][1]/oxns:namePart'
+      expect(@test_full_terminology.xpath_with_indexes('//oxns:name[@type="personal"][1]/oxns:namePart')).to eq('//oxns:name[@type="personal"][1]/oxns:namePart')
     end
     # Note: Ruby array indexes begin from 0.  In xpath queries (which start from 1 instead of 0), this will be translated accordingly.
     it "should prepend the xpath for any parent nodes, inserting calls to xpath array lookup where necessary" do
-      @test_full_terminology.xpath_with_indexes( {:conference=>0}, {:role=>1}, :text ).should == '//oxns:name[@type="conference"][1]/oxns:role[2]/oxns:roleTerm[@type="text"]'
+      expect(@test_full_terminology.xpath_with_indexes( {:conference=>0}, {:role=>1}, :text )).to eq('//oxns:name[@type="conference"][1]/oxns:role[2]/oxns:roleTerm[@type="text"]')
     end
     it "should be idempotent" do
-      @test_full_terminology.xpath_with_indexes( *[{:title_info=>2}, :main_title] ).should == "//oxns:titleInfo[3]/oxns:title"
-      @test_full_terminology.xpath_with_indexes( *[{:title_info=>2}, :main_title] ).should == "//oxns:titleInfo[3]/oxns:title"
-      @test_full_terminology.xpath_with_indexes( *[{:title_info=>2}, :main_title] ).should == "//oxns:titleInfo[3]/oxns:title"
+      expect(@test_full_terminology.xpath_with_indexes( *[{:title_info=>2}, :main_title] )).to eq("//oxns:titleInfo[3]/oxns:title")
+      expect(@test_full_terminology.xpath_with_indexes( *[{:title_info=>2}, :main_title] )).to eq("//oxns:titleInfo[3]/oxns:title")
+      expect(@test_full_terminology.xpath_with_indexes( *[{:title_info=>2}, :main_title] )).to eq("//oxns:titleInfo[3]/oxns:title")
     end
     it "should traverse named term proxies transparently" do
       proxied_xpath = @test_full_terminology.xpath_with_indexes(:journal, :issue, :pages, :start)
-      @test_full_terminology.xpath_with_indexes( :journal, :issue, :start_page ).should == proxied_xpath
+      expect(@test_full_terminology.xpath_with_indexes( :journal, :issue, :start_page )).to eq(proxied_xpath)
     end
   end
 
   describe "#xml_builder_template" do
 
     it "should generate a template call for passing into the builder block (assumes 'xml' as the argument for the block)" do
-      @test_full_terminology.xml_builder_template(:person,:date).should == 'xml.namePart( \'#{builder_new_value}\', \'type\'=>\'date\' )'
-      @test_full_terminology.xml_builder_template(:person,:person_id).should == 'xml.namePart( \'#{builder_new_value}\' )'
-      @test_full_terminology.xml_builder_template(:name,:affiliation).should == 'xml.affiliation( \'#{builder_new_value}\' )'
+      expect(@test_full_terminology.xml_builder_template(:person,:date)).to eq('xml.namePart( \'#{builder_new_value}\', \'type\'=>\'date\' )')
+      expect(@test_full_terminology.xml_builder_template(:person,:person_id)).to eq('xml.namePart( \'#{builder_new_value}\' )')
+      expect(@test_full_terminology.xml_builder_template(:name,:affiliation)).to eq('xml.affiliation( \'#{builder_new_value}\' )')
     end
 
     it "should accept extra options" do
@@ -326,44 +326,44 @@ describe "OM::XML::Terminology" do
       e1 = %q{xml.roleTerm( '#{builder_new_value}', 'type'=>'code', 'authority'=>'marcrelator' )}
       e2 = %q{xml.roleTerm( '#{builder_new_value}', 'authority'=>'marcrelator', 'type'=>'code' )}
       got = @test_full_terminology.xml_builder_template(:role, :code, {:attributes=>{"authority"=>"marcrelator"}} )
-      [e1, e2].should include(got)
+      expect([e1, e2]).to include(got)
       got = @test_full_terminology.xml_builder_template(:person, :role, :code, {:attributes=>{"authority"=>"marcrelator"}} )
-      [e1, e2].should include(got)
+      expect([e1, e2]).to include(got)
     end
 
     it "should work with deeply nested properties" do
-      @test_full_terminology.xml_builder_template(:issue, :volume).should == "xml.detail( \'type\'=>'volume' ) { xml.number( '\#{builder_new_value}' ) }"
-      @test_full_terminology.xml_builder_template(:journal, :issue, :level).should == "xml.detail( \'type\'=>'number' ) { xml.number( '\#{builder_new_value}' ) }"
-      @test_full_terminology.xml_builder_template(:journal, :issue, :volume).should == "xml.detail( \'type\'=>'volume' ) { xml.number( '\#{builder_new_value}' ) }"
-      @test_full_terminology.xml_builder_template(:journal, :issue, :pages, :start).should == "xml.start( '\#{builder_new_value}' )"
+      expect(@test_full_terminology.xml_builder_template(:issue, :volume)).to eq("xml.detail( \'type\'=>'volume' ) { xml.number( '\#{builder_new_value}' ) }")
+      expect(@test_full_terminology.xml_builder_template(:journal, :issue, :level)).to eq("xml.detail( \'type\'=>'number' ) { xml.number( '\#{builder_new_value}' ) }")
+      expect(@test_full_terminology.xml_builder_template(:journal, :issue, :volume)).to eq("xml.detail( \'type\'=>'volume' ) { xml.number( '\#{builder_new_value}' ) }")
+      expect(@test_full_terminology.xml_builder_template(:journal, :issue, :pages, :start)).to eq("xml.start( '\#{builder_new_value}' )")
     end
 
   end
 
   describe "#term_generic_name" do
     it "should generate a generic accessor name based on an array of pointers" do
-      OM::XML::Terminology.term_generic_name( {:conference=>0}, {:role=>1}, :text ).should == "conference_role_text"
-      OM::XML::Terminology.term_generic_name( *[{:conference=>0}, {:role=>1}, :text] ).should == "conference_role_text"
+      expect(OM::XML::Terminology.term_generic_name( {:conference=>0}, {:role=>1}, :text )).to eq("conference_role_text")
+      expect(OM::XML::Terminology.term_generic_name( *[{:conference=>0}, {:role=>1}, :text] )).to eq("conference_role_text")
     end
   end
 
   describe "#term_hierarchical_name" do
     it "should generate a specific accessor name based on an array of pointers and indexes" do
-      OM::XML::Terminology.term_hierarchical_name( {:conference=>0}, {:role=>1}, :text ).should == "conference_0_role_1_text"
-      OM::XML::Terminology.term_hierarchical_name( *[{:conference=>0}, {:role=>1}, :text] ).should == "conference_0_role_1_text"
+      expect(OM::XML::Terminology.term_hierarchical_name( {:conference=>0}, {:role=>1}, :text )).to eq("conference_0_role_1_text")
+      expect(OM::XML::Terminology.term_hierarchical_name( *[{:conference=>0}, {:role=>1}, :text] )).to eq("conference_0_role_1_text")
     end
   end
 
   describe ".term_builders" do
     it "should return a hash terms that have been added to the root of the terminology, indexed by term name" do
-      @test_terminology.terms[:name].should == @test_name
+      expect(@test_terminology.terms[:name]).to eq(@test_name)
     end
   end
 
   describe ".root_terms" do
     it "should return the terms that have been marked root" do
-      @test_full_terminology.root_terms.length.should == 1
-      @test_full_terminology.root_terms.first.should == @test_full_terminology.terms[:mods]
+      expect(@test_full_terminology.root_terms.length).to eq(1)
+      expect(@test_full_terminology.root_terms.first).to eq(@test_full_terminology.terms[:mods])
     end
   end