om 3.1.0 → 3.1.1

data/spec/unit/term_xpath_generator_spec.rb

@@ -27,64 +27,64 @@ describe "OM::XML::TermXpathGeneratorSpec" do
   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.should_receive(: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.should_receive(: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.should_receive(: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 = double("Term", :xpath_absolute=>'//name[@type="conference"]/role')
       @test_role_text.stub(:parent => mock_parent_mapper)
-      OM::XML::TermXpathGenerator.generate_absolute_xpath(@test_role_text).should == '//name[@type="conference"]/role/roleTerm[@type="text"]'
+      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,15 +92,15 @@ 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")]'
-      generated_xpath.should match( /\/\/oxns:name\[@type=\"personal\".*and oxns:namePart\[@type=\"given\"\]\[text\(\)=\"Tim\"\].*\]/ )
-      generated_xpath.should match( /\/\/oxns:name\[@type=\"personal\".*and oxns:namePart\[@type=\"family\"\]\[text\(\)=\"Berners-Lee\"\].*\]/ )
+      expect(generated_xpath).to match( /\/\/oxns:name\[@type=\"personal\".*and oxns:namePart\[@type=\"given\"\]\[text\(\)=\"Tim\"\].*\]/ )
+      expect(generated_xpath).to match( /\/\/oxns:name\[@type=\"personal\".*and oxns:namePart\[@type=\"family\"\]\[text\(\)=\"Berners-Lee\"\].*\]/ )
     end
 
     it "should find matching nodes" do
       ng = Nokogiri::XML(fixture( File.join("test_dummy_mods.xml")))
       generated_xpath = OM::XML::TermXpathGenerator.generate_xpath_with_indexes( @sample_terminology,
                                                     :person, {:first_name=>"Tim", :family_name=>"Berners-Lee"} )
-      ng.xpath(generated_xpath, 'oxns' => "http://www.loc.gov/mods/v3").to_xml.should be_equivalent_to <<EOF
+      expect(ng.xpath(generated_xpath, 'oxns' => "http://www.loc.gov/mods/v3").to_xml).to be_equivalent_to <<EOF
       <ns3:name type="personal">
           <ns3:namePart type="family">Berners-Lee</ns3:namePart>
           <ns3:namePart type="given">Tim</ns3:namePart>
@@ -112,33 +112,33 @@ describe "OM::XML::TermXpathGeneratorSpec" do
 EOF
       generated_xpath = OM::XML::TermXpathGenerator.generate_xpath_with_indexes( @sample_terminology,
                                                     :person, {:first_name=>"Tim", :family_name=>"Berners"} )
-      ng.xpath(generated_xpath, 'oxns' => "http://www.loc.gov/mods/v3").should be_empty 
+      expect(ng.xpath(generated_xpath, 'oxns' => "http://www.loc.gov/mods/v3")).to be_empty 
       generated_xpath = OM::XML::TermXpathGenerator.generate_xpath_with_indexes( @sample_terminology,
                                                     :person, {:first_name=>"Frank", :family_name=>"Berners-Lee"} )
-      ng.xpath(generated_xpath, 'oxns' => "http://www.loc.gov/mods/v3").should be_empty 
+      expect(ng.xpath(generated_xpath, 'oxns' => "http://www.loc.gov/mods/v3")).to be_empty 
 
       generated_xpath = OM::XML::TermXpathGenerator.generate_xpath_with_indexes( @sample_terminology,
                                                      :person, {:first_name=>"Tim", :family_name=>"Howard"} )
-      ng.xpath(generated_xpath, 'oxns' => "http://www.loc.gov/mods/v3").should be_empty 
+      expect(ng.xpath(generated_xpath, 'oxns' => "http://www.loc.gov/mods/v3")).to be_empty 
 
     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"]'
+      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.should_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")
-      @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
 
@@ -146,17 +146,14 @@ EOF
     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")
 
-    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('"', '\"')
+    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

@@ -75,41 +75,42 @@ describe "OM::XML::Terminology::Builder" do
       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"
+      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"}
+        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"})
 
-        @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[: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
     
@@ -117,42 +118,44 @@ describe "OM::XML::Terminology::Builder" do
       it "should let you load mappings from an xml file" do
         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
@@ -162,42 +165,42 @@ describe "OM::XML::Terminology::Builder" do
         skip
         
         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
+        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
+        expect(root_term_builder.settings[:is_root_term]).to  be 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(@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
     

data/spec/unit/terminology_spec.rb

@@ -89,90 +89,90 @@ 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    
         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
@@ -181,60 +181,60 @@ describe "OM::XML::Terminology" do
     it "should let you load mappings from an xml file" do
       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
       skip
-      TerminologyTest.to_xml.should == ""
+      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 true
     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 true
+      expect(@test_full_terminology.has_term?({:title_info=>"0"}, :main_title)).to be true
     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_falsey
+      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(lambda { @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
 
@@ -244,7 +244,7 @@ describe "OM::XML::Terminology" do
       # 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
       skip
-      @test_full_terminology.xpath_for(:person, {:date=>"2010"}).should == '//oxns:name[@type="personal" and contains(oxns:namePart[@type="date"], "2010")]'
+      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
       skip
-      @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")]'
+      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