citeproc-ruby 1.0.3 → 1.0.4

data/spec/citeproc/ruby/renderer/group_spec.rb

@@ -14,36 +14,36 @@ module CiteProc
       let(:node) { CSL::Style::Group.new }
 
       it 'returns an empty string by default' do
-        renderer.render(item, node).should == ''
+        expect(renderer.render(item, node)).to eq('')
 
         node[:prefix] = '!'
-        renderer.render(item, node).should == ''
+        expect(renderer.render(item, node)).to eq('')
       end
 
       describe 'when there is a text node in the group' do
         before(:each) { node << CSL::Style::Text.new( :term => 'retrieved') }
 
         it 'returns the content of the nested node' do
-          renderer.render_group(item, node).should == 'retrieved'
+          expect(renderer.render_group(item, node)).to eq('retrieved')
         end
 
         it 'applies formatting options to the nested node' do
           node[:'text-case'] = 'uppercase'
-          renderer.render(item, node).should == 'RETRIEVED'
+          expect(renderer.render(item, node)).to eq('RETRIEVED')
         end
 
         describe 'when there is a second text node in the group' do
           before(:each) { node << CSL::Style::Text.new( :term => 'from') }
 
           it 'returns the content of both nested nodes' do
-            renderer.render_group(item, node).should == 'retrievedfrom'
+            expect(renderer.render_group(item, node)).to eq('retrievedfrom')
           end
 
           describe 'when there is a delimter set on the group node' do
             before(:each) { node[:delimiter] = ' ' }
 
             it 'applies the delimiter to the output' do
-              renderer.render_group(item, node).should == 'retrieved from'
+              expect(renderer.render_group(item, node)).to eq('retrieved from')
             end
 
             it 'applies formatting options to the nested nodes only' do
@@ -51,7 +51,7 @@ module CiteProc
               node[:delimiter] = ' foo '
               node[:prefix] = '('
               node[:suffix] = ')'
-              renderer.render(item, node).should == '(RETRIEVED foo FROM)'
+              expect(renderer.render(item, node)).to eq('(RETRIEVED FOO FROM)')
             end
 
             describe 'when a nested node produces no output' do
@@ -61,7 +61,7 @@ module CiteProc
               end
 
               it 'the delimiter does not apply to it' do
-                renderer.render_group(item, node).should == 'retrieved from from'
+                expect(renderer.render_group(item, node)).to eq('retrieved from from')
               end
             end
 
@@ -69,14 +69,14 @@ module CiteProc
               before(:each) { node << CSL::Style::Text.new( :variable => 'URL') }
 
               it 'returns the empty string when the variable is not present in the item' do
-                renderer.render_group(item, node).should == ''
+                expect(renderer.render_group(item, node)).to eq('')
               end
 
               describe 'when the variable is present' do
                 before(:each) { item.data[:URL] = 'http://example.org' };
 
                 it 'returns all nested renditions' do
-                  renderer.render_group(item, node).should == 'retrieved from http://example.org'
+                  expect(renderer.render_group(item, node)).to eq('retrieved from http://example.org')
                 end
               end
             end

data/spec/citeproc/ruby/renderer/history_spec.rb

@@ -8,37 +8,37 @@ module CiteProc
       let(:history) { state.history }
 
       it 'has an empty citation history' do
-        history.memory['citation'].should == []
+        expect(history.memory['citation']).to eq([])
       end
 
       it 'has an empty bibliography history' do
-        history.memory['bibliogrpahy'].should == []
+        expect(history.memory['bibliogrpahy']).to eq([])
       end
 
       describe '#update' do
         it 'saves the passed in items for :store!' do
-          lambda {
+          expect {
             history.update :store!, 'citation', { :x => 1 }
-          }.should change { history.citation }.to([{ :x => 1 }])
+          }.to change { history.citation }.to([{ :x => 1 }])
         end
 
         it 'drops remembered items when they are too old' do
-          lambda {
+          expect {
             history.update :store!, 'citation', { :x => 1 }
             history.update :store!, 'citation', { :x => 2 }
             history.update :store!, 'citation', { :x => 3 }
             history.update :store!, 'citation', { :x => 4 }
             history.update :store!, 'citation', { :x => 5 }
-          }.should change { history.citation.length }.to(3)
+          }.to change { history.citation.length }.to(3)
         end
       end
 
       describe '#discard' do
         it 'clears the history' do
           history.update :store!, 'bibliography', { :x => 1 }
-          history.memory.should_not be_empty
+          expect(history.memory).not_to be_empty
           history.discard
-          history.memory.should be_empty
+          expect(history.memory).to be_empty
         end
       end
     end

data/spec/citeproc/ruby/renderer/label_spec.rb

@@ -16,12 +16,12 @@ module CiteProc
 
       describe 'given an empty node' do
         it 'returns an empty string for an empty item' do
-          renderer.render_label(item, node).should == ''
+          expect(renderer.render_label(item, node)).to eq('')
         end
 
         it 'returns an empty string for an item with variables' do
           item.data.edition = 'foo'
-          renderer.render_label(item, node).should == ''
+          expect(renderer.render_label(item, node)).to eq('')
         end
       end
 
@@ -33,27 +33,27 @@ module CiteProc
 
         describe "for an item with no page value" do
           it 'returns an empty string' do
-            renderer.render_label(item, node).should == ''
+            expect(renderer.render_label(item, node)).to eq('')
           end
         end
 
         describe 'for an item with a page value' do
           it 'returns the singular label for a number' do
             item.write_attribute :page, '23'
-            renderer.render_label(item, node).should == 'page'
+            expect(renderer.render_label(item, node)).to eq('page')
           end
 
           it 'returns the plural label for a page-range' do
             item.write_attribute :page, '23-24'
-            renderer.render_label(item, node).should == 'pages'
+            expect(renderer.render_label(item, node)).to eq('pages')
           end
 
           it 'returns the plural label for multiple pages' do
             item.write_attribute :page, '23 & 24'
-            renderer.render_label(item, node).should == 'pages'
+            expect(renderer.render_label(item, node)).to eq('pages')
 
             item.write_attribute :page, '23, 24, 25'
-            renderer.render_label(item, node).should == 'pages'
+            expect(renderer.render_label(item, node)).to eq('pages')
           end
 
           describe 'when pluralization is contextual' do
@@ -61,12 +61,12 @@ module CiteProc
 
             it 'returns the singular label for a number' do
               item.write_attribute :page, '23'
-              renderer.render_label(item, node).should == 'page'
+              expect(renderer.render_label(item, node)).to eq('page')
             end
 
             it 'returns the plural label for a page-range' do
               item.write_attribute :page, '23-24'
-              renderer.render_label(item, node).should == 'pages'
+              expect(renderer.render_label(item, node)).to eq('pages')
             end
           end
 
@@ -75,12 +75,12 @@ module CiteProc
 
             it 'returns the singular label for a number' do
               item.write_attribute :page, '1'
-              renderer.render_label(item, node).should == 'pages'
+              expect(renderer.render_label(item, node)).to eq('pages')
             end
 
             it 'returns the plural label for a page-range' do
               item.write_attribute :page, '1-3'
-              renderer.render_label(item, node).should == 'pages'
+              expect(renderer.render_label(item, node)).to eq('pages')
             end
           end
 
@@ -89,12 +89,12 @@ module CiteProc
 
             it 'returns the singular label for a number' do
               item.write_attribute :page, '1'
-              renderer.render_label(item, node).should == 'page'
+              expect(renderer.render_label(item, node)).to eq('page')
             end
 
             it 'returns the plural label for a page-range' do
               item.write_attribute :page, '1-3'
-              renderer.render_label(item, node).should == 'page'
+              expect(renderer.render_label(item, node)).to eq('page')
             end
           end
         end
@@ -108,22 +108,22 @@ module CiteProc
 
         describe "for an item with no 'number-of-pages' value" do
           it 'returns an empty string' do
-            renderer.render_label(item, node).should == ''
+            expect(renderer.render_label(item, node)).to eq('')
           end
         end
 
         describe "for an item with a 'number-of-pages' value" do
           it 'returns the singular label for number 1' do
             item.data[:'number-of-pages'] = 1
-            renderer.render_label(item, node).should == 'page'
+            expect(renderer.render_label(item, node)).to eq('page')
           end
 
           it 'returns the plural label for numbers higher than 1' do
             item.data[:'number-of-pages'] = '2'
-            renderer.render_label(item, node).should == 'pages'
+            expect(renderer.render_label(item, node)).to eq('pages')
 
             item.data[:'number-of-pages'] = 42
-            renderer.render_label(item, node).should == 'pages'
+            expect(renderer.render_label(item, node)).to eq('pages')
           end
 
           describe 'when pluralization is set to "contextual"' do
@@ -131,15 +131,15 @@ module CiteProc
 
             it 'returns the singular label for number 1' do
               item.data[:'number-of-pages'] = '1'
-              renderer.render_label(item, node).should == 'page'
+              expect(renderer.render_label(item, node)).to eq('page')
             end
 
             it 'returns the plural label for numbers higher than 1' do
               item.data[:'number-of-pages'] = '2'
-              renderer.render_label(item, node).should == 'pages'
+              expect(renderer.render_label(item, node)).to eq('pages')
 
               item.data[:'number-of-pages'] = 42
-              renderer.render_label(item, node).should == 'pages'
+              expect(renderer.render_label(item, node)).to eq('pages')
             end
           end
 
@@ -148,15 +148,15 @@ module CiteProc
 
             it 'returns the singular label for number 1' do
               item.data[:'number-of-pages'] = 1
-              renderer.render_label(item, node).should == 'pages'
+              expect(renderer.render_label(item, node)).to eq('pages')
             end
 
             it 'returns the plural label for numbers higher than 1' do
               item.data[:'number-of-pages'] = '2'
-              renderer.render_label(item, node).should == 'pages'
+              expect(renderer.render_label(item, node)).to eq('pages')
 
               item.data[:'number-of-pages'] = 42
-              renderer.render_label(item, node).should == 'pages'
+              expect(renderer.render_label(item, node)).to eq('pages')
             end
           end
 
@@ -165,15 +165,15 @@ module CiteProc
 
             it 'returns the singular label for number 1' do
               item.data[:'number-of-pages'] = 1
-              renderer.render_label(item, node).should == 'page'
+              expect(renderer.render_label(item, node)).to eq('page')
             end
 
             it 'returns the plural label for numbers higher than 1' do
               item.data[:'number-of-pages'] = '2'
-              renderer.render_label(item, node).should == 'page'
+              expect(renderer.render_label(item, node)).to eq('page')
 
               item.data[:'number-of-pages'] = 42
-              renderer.render_label(item, node).should == 'page'
+              expect(renderer.render_label(item, node)).to eq('page')
             end
           end
         end
@@ -187,15 +187,15 @@ module CiteProc
         describe "for an item with a 'number-of-volumes' value" do
           it 'returns the singular label for number 1' do
             item.data[:'number-of-volumes'] = 1
-            renderer.render_label(item, node).should == 'volume'
+            expect(renderer.render_label(item, node)).to eq('volume')
           end
 
           it 'returns the plural label for numbers higher than 1' do
             item.data[:'number-of-volumes'] = '2'
-            renderer.render_label(item, node).should == 'volumes'
+            expect(renderer.render_label(item, node)).to eq('volumes')
 
             item.data[:'number-of-volumes'] = 42
-            renderer.render_label(item, node).should == 'volumes'
+            expect(renderer.render_label(item, node)).to eq('volumes')
           end
         end
       end
@@ -209,13 +209,13 @@ module CiteProc
           it "returns the singular label for a single number" do
             item.locator = 2
             item.label = 'book'
-            renderer.render_label(item, node).should == 'book'
+            expect(renderer.render_label(item, node)).to eq('book')
           end
 
           it "returns the plural label for multiple numbers" do
             item.locator = '23 & 4'
             item.label = 'book'
-            renderer.render_label(item, node).should == 'books'
+            expect(renderer.render_label(item, node)).to eq('books')
           end
         end
       end

data/spec/citeproc/ruby/renderer/layout_spec.rb

@@ -15,7 +15,7 @@ module CiteProc
       }
 
       it 'returns an empty string when empty' do
-        renderer.render(item, node).should == ''
+        expect(renderer.render(item, node)).to eq('')
       end
 
       describe 'with child nodes' do
@@ -25,12 +25,12 @@ module CiteProc
         end
 
         it 'renders each child' do
-          renderer.render(item, node).should == 'foobar'
+          expect(renderer.render(item, node)).to eq('foobar')
         end
 
         it 'uses the delimiters if specified' do
           node[:delimiter] = '-'
-          renderer.render(item, node).should == 'foo-bar'
+          expect(renderer.render(item, node)).to eq('foo-bar')
         end
       end
 

data/spec/citeproc/ruby/renderer/macro_spec.rb

@@ -15,14 +15,14 @@ module CiteProc
       }
 
       it 'returns an empty string when empty' do
-        renderer.render(item, node).should == ''
+        expect(renderer.render(item, node)).to eq('')
       end
 
       it 'renders each child' do
         node << CSL::Style::Text.new(:value => 'foo')
         node << CSL::Style::Text.new(:value => 'bar')
 
-        renderer.render(item, node).should == 'foobar'
+        expect(renderer.render(item, node)).to eq('foobar')
       end
 
     end

data/spec/citeproc/ruby/renderer/names_spec.rb

@@ -21,12 +21,12 @@ module CiteProc
 
       describe 'given an empty node' do
         it 'returns an empty string for an empty item' do
-          renderer.render(item, node).should == ''
+          expect(renderer.render(item, node)).to eq('')
         end
 
         it 'returns an empty string for an item with variables' do
           item.data.edition = 'foo'
-          renderer.render_names(item, node).should == ''
+          expect(renderer.render_names(item, node)).to eq('')
         end
       end
 
@@ -37,17 +37,17 @@ module CiteProc
         end
 
         it 'formats it in long form' do
-          renderer.render_names(item, node).should == 'Edgar Allen Poe'
+          expect(renderer.render_names(item, node)).to eq('Edgar Allen Poe')
         end
 
         it 'supports nested name node options' do
           node << CSL::Style::Name.new(:form => 'short')
-          renderer.render_names(item, node).should == 'Poe'
+          expect(renderer.render_names(item, node)).to eq('Poe')
         end
 
         it 'supports nested label node' do
           node << CSL::Style::Label.new(:prefix => ' [', :suffix => ']')
-          renderer.render_names(item, node).should == 'Edgar Allen Poe [author]'
+          expect(renderer.render_names(item, node)).to eq('Edgar Allen Poe [author]')
         end
       end
 
@@ -58,17 +58,17 @@ module CiteProc
         end
 
         it 'formats them as a list' do
-          renderer.render_names(item, node).should == 'Plato, Socrates, Aristotle'
+          expect(renderer.render_names(item, node)).to eq('Plato, Socrates, Aristotle')
         end
 
         it 'supports nested name node options' do
           node << CSL::Style::Name.new(:and => 'symbol')
-          renderer.render_names(item, node).should == 'Plato, Socrates, & Aristotle'
+          expect(renderer.render_names(item, node)).to eq('Plato, Socrates, & Aristotle')
         end
 
         it 'supports nested label node' do
           node << CSL::Style::Label.new(:prefix => ' (', :suffix => ')')
-          renderer.render_names(item, node).should == 'Plato, Socrates, Aristotle (editors)'
+          expect(renderer.render_names(item, node)).to eq('Plato, Socrates, Aristotle (editors)')
         end
       end
 
@@ -79,13 +79,13 @@ module CiteProc
         end
 
         it 'renders all matching lists combinded using default delimiter' do
-          renderer.render_names(item, node).should == ''
+          expect(renderer.render_names(item, node)).to eq('')
 
           item.data.author = poe
-          renderer.render_names(item, node).should == 'Edgar Allen Poe'
+          expect(renderer.render_names(item, node)).to eq('Edgar Allen Poe')
 
           item.data.editor = philosophers
-          renderer.render_names(item, node).should == 'Edgar Allen Poe; Plato, Socrates, Aristotle'
+          expect(renderer.render_names(item, node)).to eq('Edgar Allen Poe; Plato, Socrates, Aristotle')
         end
 
         it 'keeps the variable order' do
@@ -93,7 +93,7 @@ module CiteProc
           item.data.editor = philosophers
 
           node[:variable] = 'editor author'
-          renderer.render_names(item, node).should == 'Plato, Socrates, Aristotle; Edgar Allen Poe'
+          expect(renderer.render_names(item, node)).to eq('Plato, Socrates, Aristotle; Edgar Allen Poe')
         end
 
         it 'supports labels' do
@@ -102,7 +102,7 @@ module CiteProc
 
           node << CSL::Style::Label.new(:prefix => ' (', :suffix => ')')
 
-          renderer.render_names(item, node).should == 'Edgar Allen Poe (author); Plato, Socrates, Aristotle (editors)'
+          expect(renderer.render_names(item, node)).to eq('Edgar Allen Poe (author); Plato, Socrates, Aristotle (editors)')
         end
 
         it 'resolves the editor translator special case' do
@@ -116,14 +116,14 @@ module CiteProc
           node.name = { :and => 'symbol', :form => 'short' }
           node.label = { :prefix => ' (', :suffix => ')' }
 
-          renderer.render_names(item, node).should == 'Poe (author); Quinn & Thompson (editors)'
+          expect(renderer.render_names(item, node)).to eq('Poe (author); Quinn & Thompson (editors)')
 
           item.data.translator = poe
-          renderer.render_names(item, node).should == 'Poe (translator); Poe (author); Quinn & Thompson (editors)'
+          expect(renderer.render_names(item, node)).to eq('Poe (translator); Poe (author); Quinn & Thompson (editors)')
 
           item.data.translator = 'Patrick F. Quinn and G. R. Thompson'
 
-          renderer.render(item, node).should == 'Quinn & Thompson (editors & translators); Poe (author)'
+          expect(renderer.render(item, node)).to eq('Quinn & Thompson (editors & translators); Poe (author)')
         end
       end
     end
@@ -138,65 +138,65 @@ module CiteProc
 
       describe 'given an empty node' do
         it 'returns an empty string given no names' do
-          renderer.render_name(CiteProc::Names.new, node).should == ''
+          expect(renderer.render_name(CiteProc::Names.new, node)).to eq('')
         end
 
         it 'formats the given name in long form' do
-          renderer.render_name(poe, node).should == 'Edgar Allen Poe'
+          expect(renderer.render_name(poe, node)).to eq('Edgar Allen Poe')
         end
 
         it 'formats multiple names delimitted by commas' do
-          renderer.render_name(philosophers, node).should == 'Plato, Socrates, Aristotle'
+          expect(renderer.render_name(philosophers, node)).to eq('Plato, Socrates, Aristotle')
         end
       end
 
       describe 'given a node with and "and" attribute' do
         it 'inserts a delimited connector' do
           node[:and] = 'symbol'
-          renderer.render_name(philosophers, node).should == 'Plato, Socrates, & Aristotle'
+          expect(renderer.render_name(philosophers, node)).to eq('Plato, Socrates, & Aristotle')
 
           node[:and] = 'text'
-          renderer.render_name(philosophers, node).should == 'Plato, Socrates, and Aristotle'
+          expect(renderer.render_name(philosophers, node)).to eq('Plato, Socrates, and Aristotle')
         end
       end
 
       describe 'given a node with delimier-precedes-last' do
         it 'inserts final delimiter only for three or more names when set to "contextual"' do
           node.delimiter_contextually_precedes_last!
-          renderer.render_name(philosophers, node).should == 'Plato, Socrates, Aristotle'
+          expect(renderer.render_name(philosophers, node)).to eq('Plato, Socrates, Aristotle')
 
           node[:and] = 'text'
-          renderer.render_name(philosophers, node).should == 'Plato, Socrates, and Aristotle'
+          expect(renderer.render_name(philosophers, node)).to eq('Plato, Socrates, and Aristotle')
 
-          renderer.render_name(philosophers.take(2), node).should == 'Plato and Socrates'
+          expect(renderer.render_name(philosophers.take(2), node)).to eq('Plato and Socrates')
 
           node[:and] = nil
-          renderer.render_name(philosophers.take(2), node).should == 'Plato, Socrates'
+          expect(renderer.render_name(philosophers.take(2), node)).to eq('Plato, Socrates')
         end
 
         it 'inserts final delimiter when set to "always"' do
           node.delimiter_always_precedes_last!
 
-          renderer.render_name(philosophers, node).should == 'Plato, Socrates, Aristotle'
+          expect(renderer.render_name(philosophers, node)).to eq('Plato, Socrates, Aristotle')
 
           node[:and] = 'text'
-          renderer.render_name(philosophers, node).should == 'Plato, Socrates, and Aristotle'
+          expect(renderer.render_name(philosophers, node)).to eq('Plato, Socrates, and Aristotle')
 
-          renderer.render_name(philosophers.take(2), node).should == 'Plato, and Socrates'
+          expect(renderer.render_name(philosophers.take(2), node)).to eq('Plato, and Socrates')
 
           node[:and] = nil
-          renderer.render_name(philosophers.take(2), node).should == 'Plato, Socrates'
+          expect(renderer.render_name(philosophers.take(2), node)).to eq('Plato, Socrates')
         end
 
         it 'never inserts final delimiter when set to "never" (unless there is no "and")' do
           node.delimiter_never_precedes_last!
 
-          renderer.render_name(philosophers, node).should == 'Plato, Socrates, Aristotle'
-          renderer.render_name(philosophers.take(2), node).should == 'Plato, Socrates'
+          expect(renderer.render_name(philosophers, node)).to eq('Plato, Socrates, Aristotle')
+          expect(renderer.render_name(philosophers.take(2), node)).to eq('Plato, Socrates')
 
           node[:and] = 'text'
-          renderer.render_name(philosophers, node).should == 'Plato, Socrates and Aristotle'
-          renderer.render_name(philosophers.take(2), node).should == 'Plato and Socrates'
+          expect(renderer.render_name(philosophers, node)).to eq('Plato, Socrates and Aristotle')
+          expect(renderer.render_name(philosophers.take(2), node)).to eq('Plato and Socrates')
         end
 
         it 'supports only-after-inverted-name rule' do
@@ -204,20 +204,20 @@ module CiteProc
           node.delimiter_precedes_last_after_inverted_name!
 
           # always delimit when there is no and!
-          renderer.render_name(names, node).should == 'J. Doe, S. Smith, T. Williams'
-          renderer.render_name(names.take(2), node).should == 'J. Doe, S. Smith'
+          expect(renderer.render_name(names, node)).to eq('J. Doe, S. Smith, T. Williams')
+          expect(renderer.render_name(names.take(2), node)).to eq('J. Doe, S. Smith')
 
           node[:and] = 'text'
-          renderer.render_name(names, node).should == 'J. Doe, S. Smith and T. Williams'
-          renderer.render_name(names.take(2), node).should == 'J. Doe and S. Smith'
+          expect(renderer.render_name(names, node)).to eq('J. Doe, S. Smith and T. Williams')
+          expect(renderer.render_name(names.take(2), node)).to eq('J. Doe and S. Smith')
 
           node[:'name-as-sort-order'] = 'first'
-          renderer.render_name(names, node).should == 'Doe, J., S. Smith and T. Williams'
-          renderer.render_name(names.take(2), node).should == 'Doe, J., and S. Smith'
+          expect(renderer.render_name(names, node)).to eq('Doe, J., S. Smith and T. Williams')
+          expect(renderer.render_name(names.take(2), node)).to eq('Doe, J., and S. Smith')
 
           node[:'name-as-sort-order'] = 'all'
-          renderer.render_name(names, node).should == 'Doe, J., Smith, S., and Williams, T.'
-          renderer.render_name(names.take(2), node).should == 'Doe, J., and Smith, S.'
+          expect(renderer.render_name(names, node)).to eq('Doe, J., Smith, S., and Williams, T.')
+          expect(renderer.render_name(names.take(2), node)).to eq('Doe, J., and Smith, S.')
         end
       end
 
@@ -229,12 +229,12 @@ module CiteProc
           node[:'et-al-use-first'] = 2
 
           others = CSL::Style::EtAl.new(:prefix => '!!')
-          node.stub(:et_al).and_return(others)
+          allow(node).to receive(:et_al).and_return(others)
 
-          renderer.render_name(names, node).should == 'J. Doe, S. Smith, !!et al.'
+          expect(renderer.render_name(names, node)).to eq('J. Doe, S. Smith, !!et al.')
 
           others[:term] = 'and others'
-          renderer.render_name(names, node).should == 'J. Doe, S. Smith, !!and others'
+          expect(renderer.render_name(names, node)).to eq('J. Doe, S. Smith, !!and others')
         end
 
         it 'supports et-al-use-last' do
@@ -243,10 +243,10 @@ module CiteProc
           node[:'et-al-use-last'] = true
 
           # truncated list must be at least two names short!
-          renderer.render_name(names, node).should == 'J. Doe, S. Smith, et al.'
+          expect(renderer.render_name(names, node)).to eq('J. Doe, S. Smith, et al.')
 
           node[:'et-al-use-first'] = 1
-          renderer.render_name(names, node).should == 'J. Doe, … T. Williams'
+          expect(renderer.render_name(names, node)).to eq('J. Doe, … T. Williams')
         end
 
         describe 'with default delimiter settings' do
@@ -254,17 +254,17 @@ module CiteProc
             node[:'et-al-min'] = 3
             node[:'et-al-use-first'] = 2
 
-            renderer.render_name(names, node).should == 'J. Doe, S. Smith, et al.'
+            expect(renderer.render_name(names, node)).to eq('J. Doe, S. Smith, et al.')
 
             node[:'et-al-use-first'] = 1
-            renderer.render_name(names, node).should == 'J. Doe et al.'
+            expect(renderer.render_name(names, node)).to eq('J. Doe et al.')
           end
 
           it 'does not truncate the list if it is less than et-al-min' do
             node[:'et-al-min'] = 4
             node[:'et-al-use-first'] = 2
 
-            renderer.render_name(names, node).should == 'J. Doe, S. Smith, T. Williams'
+            expect(renderer.render_name(names, node)).to eq('J. Doe, S. Smith, T. Williams')
           end
         end
 
@@ -274,17 +274,17 @@ module CiteProc
             node.truncate_at! 2
 
             # default behaviour should match contextual!
-            renderer.render_name(philosophers, node).should == 'Plato, Socrates, et al.'
+            expect(renderer.render_name(philosophers, node)).to eq('Plato, Socrates, et al.')
 
             node.truncate_at! 1
-            renderer.render_name(philosophers, node).should == 'Plato et al.'
+            expect(renderer.render_name(philosophers, node)).to eq('Plato et al.')
 
             # set contextual explicitly
             node.delimiter_contextually_precedes_et_al!
-            renderer.render_name(philosophers, node).should == 'Plato et al.'
+            expect(renderer.render_name(philosophers, node)).to eq('Plato et al.')
 
             node.truncate_at! 2
-            renderer.render_name(philosophers, node).should == 'Plato, Socrates, et al.'
+            expect(renderer.render_name(philosophers, node)).to eq('Plato, Socrates, et al.')
           end
 
           it 'inserts delimiter when set to "always"' do
@@ -292,10 +292,10 @@ module CiteProc
             node.truncate_at! 2
 
             node.delimiter_always_precedes_et_al!
-            renderer.render_name(philosophers, node).should == 'Plato, Socrates, et al.'
+            expect(renderer.render_name(philosophers, node)).to eq('Plato, Socrates, et al.')
 
             node.truncate_at! 1
-            renderer.render_name(philosophers, node).should == 'Plato, et al.'
+            expect(renderer.render_name(philosophers, node)).to eq('Plato, et al.')
           end
 
           it 'never inserts delimiter when set to "never"' do
@@ -303,10 +303,10 @@ module CiteProc
             node.truncate_at! 2
 
             node.delimiter_never_precedes_et_al!
-            renderer.render_name(philosophers, node).should == 'Plato, Socrates et al.'
+            expect(renderer.render_name(philosophers, node)).to eq('Plato, Socrates et al.')
 
             node.truncate_at! 1
-            renderer.render_name(philosophers, node).should == 'Plato et al.'
+            expect(renderer.render_name(philosophers, node)).to eq('Plato et al.')
           end
 
           it 'supports only-after-inverted-name rule' do
@@ -315,19 +315,19 @@ module CiteProc
 
             node.delimiter_precedes_et_al_after_inverted_name!
 
-            renderer.render_name(names, node).should == 'J. Doe, S. Smith et al.'
+            expect(renderer.render_name(names, node)).to eq('J. Doe, S. Smith et al.')
 
             node[:'name-as-sort-order'] = 'first'
-            renderer.render_name(names, node).should == 'Doe, J., S. Smith et al.'
+            expect(renderer.render_name(names, node)).to eq('Doe, J., S. Smith et al.')
 
             node.truncate_at! 1
-            renderer.render_name(names, node).should == 'Doe, J., et al.'
+            expect(renderer.render_name(names, node)).to eq('Doe, J., et al.')
 
             node[:'name-as-sort-order'] = 'all'
-            renderer.render_name(names, node).should == 'Doe, J., et al.'
+            expect(renderer.render_name(names, node)).to eq('Doe, J., et al.')
 
             node.truncate_at! 2
-            renderer.render_name(names, node).should == 'Doe, J., Smith, S., et al.'
+            expect(renderer.render_name(names, node)).to eq('Doe, J., Smith, S., et al.')
           end
         end
       end
@@ -338,15 +338,15 @@ module CiteProc
 
         it 'supports family name formatting' do
           part[:name] = 'family'
-          renderer.render_name(poe, node).should == 'Edgar Allen POE'
+          expect(renderer.render_name(poe, node)).to eq('Edgar Allen POE')
         end
 
         it 'family part includes non-demoted particles' do
           part[:name] = 'family'
 
-          renderer.render_name(people(:la_fontaine), node).should == 'Jean de LA FONTAINE'
-          renderer.render_name(people(:humboldt), node).should == 'Alexander von HUMBOLDT'
-          renderer.render_name(people(:van_gogh), node).should == 'Vincent VAN GOGH'
+          expect(renderer.render_name(people(:la_fontaine), node)).to eq('Jean de LA FONTAINE')
+          expect(renderer.render_name(people(:humboldt), node)).to eq('Alexander von HUMBOLDT')
+          expect(renderer.render_name(people(:van_gogh), node)).to eq('Vincent VAN GOGH')
         end
 
         it 'family part affixes includes name suffix for non-inverted names' do
@@ -355,20 +355,20 @@ module CiteProc
           la_fontaine = people(:la_fontaine)
           la_fontaine[0].suffix = 'Jr.'
 
-          renderer.render_name(la_fontaine, node).should == 'Jean de (LA FONTAINE Jr.)'
+          expect(renderer.render_name(la_fontaine, node)).to eq('Jean de (LA FONTAINE Jr.)')
         end
 
         it 'supports given name formatting' do
           part[:name] = 'given'
-          renderer.render_name(poe, node).should == 'EDGAR ALLEN Poe'
+          expect(renderer.render_name(poe, node)).to eq('EDGAR ALLEN Poe')
         end
 
         it 'given part includes particles' do
           part[:name] = 'given'
 
-          renderer.render_name(people(:la_fontaine), node).should == 'JEAN DE La Fontaine'
-          renderer.render_name(people(:humboldt), node).should == 'ALEXANDER VON Humboldt'
-          renderer.render_name(people(:van_gogh), node).should == 'VINCENT van Gogh'
+          expect(renderer.render_name(people(:la_fontaine), node)).to eq('JEAN DE La Fontaine')
+          expect(renderer.render_name(people(:humboldt), node)).to eq('ALEXANDER VON Humboldt')
+          expect(renderer.render_name(people(:van_gogh), node)).to eq('VINCENT van Gogh')
         end
 
         it 'given part affixes enclose demoted particles' do
@@ -376,19 +376,19 @@ module CiteProc
 
           la_fontaine = people(:la_fontaine)
 
-          renderer.render_name(la_fontaine, node).should == '(JEAN DE) La Fontaine'
+          expect(renderer.render_name(la_fontaine, node)).to eq('(JEAN DE) La Fontaine')
 
           node.all_names_as_sort_order!
-          renderer.render_name(la_fontaine, node).should == 'La Fontaine, (JEAN DE)'
+          expect(renderer.render_name(la_fontaine, node)).to eq('La Fontaine, (JEAN DE)')
 
           la_fontaine[0].always_demote_particle!
-          renderer.render_name(la_fontaine, node).should == 'Fontaine, (JEAN DE La)'
+          expect(renderer.render_name(la_fontaine, node)).to eq('Fontaine, (JEAN DE La)')
         end
 
         it 'does not alter the passed-in name object' do
           part[:name] = 'family'
-          renderer.render_name(poe, node).should == 'Edgar Allen POE'
-          poe.to_s.should == 'Edgar Allen Poe'
+          expect(renderer.render_name(poe, node)).to eq('Edgar Allen POE')
+          expect(poe.to_s).to eq('Edgar Allen Poe')
         end
       end
     end