citeproc-ruby 1.0.3 → 1.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a1c1fa2691a4268ad6ffe4179297403903b02a85
-  data.tar.gz: d8427fe01212ad953da919decf1b0067be04fedf
+  metadata.gz: e756496c808486d203583577671f08175a5113d1
+  data.tar.gz: dfd2e6adf39560078d978283708b4bdcfc378f5f
 SHA512:
-  metadata.gz: d175b7dc36cfcb3fe3a7ba149fb8701b7d934fc0153ce665480656f8eb1b9cc603d0c8fe9ee56bd9ffe1ee397cfb5065f01abf21444e50496a346b39c7d0f669
-  data.tar.gz: dc5c94bbff06808c9a922e8687d8f8fdf4176eea08d26761c8833d30b589ff2c00b84f4bbb4e39a096065635eef5657705decce6c9a117cccd1a6f9b4b697308
+  metadata.gz: 3303beb92c6d4a9c50e692c14b25ba3a523aaf57ef0983b9c7a48e5f85a7f65509a4ae95cbe776d88a2213d1decc0e5aa7dfa94bc0a44ec3f408b1be5195e8b2
+  data.tar.gz: 773cdf7b9135c95ec2cdaf7cb9779108e1840509d9f0f9c8e393aeef49c0a5f8fab3537d5efc9ebc783b24cea7a01247196666f1048b2a78aca9d4d0b6926dff

data/Gemfile

@@ -6,7 +6,7 @@ gemspec
 
 group :development, :test do
   gem 'rake', '~>10.0'
-  gem 'rspec', '~>2.13'
+  gem 'rspec', '~>3.0'
   gem 'cucumber', '~>1.2'
   gem 'simplecov', '~>0.8'
   gem 'rubinius-coverage', :platforms => [:rbx]

data/features/renderer.feature

@@ -46,7 +46,7 @@ Feature: Rendering CSL nodes
       """
       <group>
         <group suffix=" " font-weight="bold">
-          <!--group formatting is pushed down-->
+          <!--group formatting is not pushed down-->
           <text variable="volume" suffix=","/>
         </group>
         <text variable="page" suffix="," font-weight="bold"/>
@@ -55,7 +55,7 @@ Feature: Rendering CSL nodes
     When I render the following citation item as "html":
       | volume |   5 |
       | page   |  23 |
-    Then the result should be: <b>5</b>, <b>23</b>,
+    Then the result should be: <b>5,</b> <b>23</b>,
 
   Scenario: Page labels
     Given the following style node:

data/features/step_definitions/renderer.rb

@@ -47,8 +47,8 @@ When(/^I sort the following items:$/) do |items|
 
   unless @macro.nil?
     @sort.each_child do |key|
-      key.stub(:macro).and_return(@macro)
-      key.stub(:macro?).and_return(true)
+      allow(key).to receive(:macro).and_return(@macro)
+      allow(key).to receive(:macro?).and_return(true)
     end
   end
 
@@ -58,23 +58,23 @@ end
 Then(/^the results should be:$/) do |expected|
   expected = expected.raw.map(&:first)
 
-  @results.length.should == expected.length
+  expect(@results.length).to eq(expected.length)
 
   @results.zip(expected).each do |result, expectation|
-    result.should == expectation
+    expect(result).to eq(expectation)
   end
 end
 
 Then(/^the result should be: (.*)$/) do |expected|
-  @result.should == expected
+  expect(@result).to eq(expected)
 end
 
 Then(/^the order should be:$/) do |expected|
   expected = expected.raw.map(&:first)
 
-  @order.length.should == expected.length
+  expect(@order.length).to eq(expected.length)
 
   @order.zip(expected).each do |order, expectation|
-    order['id'].should == expectation
+    expect(order['id']).to eq(expectation)
   end
 end

data/features/support/env.rb

@@ -19,7 +19,7 @@ rescue LoadError
   # ignore
 end
 
-require 'cucumber/rspec/doubles'
+require 'rspec/mocks/standalone'
 require 'citeproc/ruby'
 
 module Fixtures

data/lib/citeproc/ruby/format.rb

@@ -10,19 +10,13 @@ module CiteProc
       @squeezable = /^[\s\.,:;!?\)\(\[\]]+$/
 
       @stopwords = {
-        :en => [
-          'about', 'above', 'across', 'afore', 'after', 'against', 'along',
-          'alongside', 'amid', 'amidst', 'among', 'amongst', 'anenst', 'apropos',
-          'apud', 'around', 'as', 'aside', 'astride', 'at', 'athwart', 'atop',
-          'barring', 'before', 'behind', 'below', 'beneath', 'beside', 'besides',
-          'between', 'beyond', 'but', 'by', 'circa', 'despite', 'd', 'down', 'during',
-          'except', 'for', 'forenenst', 'from', 'given', 'in', 'inside', 'into',
-          'lest', 'like', 'modulo' 'near', 'next', 'notwithstanding', 'of', 'off',
-          'on', 'onto', 'out', 'over', 'per', 'plus', 'pro', 'qua', 'sans', 'since',
-          'than', 'through', 'thru', 'throughout', 'thruout', 'till', 'to', 'toward',
-          'towards', 'under', 'underneath', 'until', 'unto', 'up', 'upon', 'versus',
-          'vs', 'v', 'via', 'vis-à-vis', 'with', 'within', 'without'
-        ]
+        :en => %w(a about above across afore after against along alongside amid amidst among amongst
+          an and anenst apropos apud around as aside astride at athwart atop barring before behind
+          below beneath beside besides between beyond but by circa despite d down during except for
+          forenenst from given in inside into lest like modulo near next nor notwithstanding of off
+          on onto or out over per plus pro qua sans since so than the through thru throughout thruout
+          till to toward towards under underneath until unto up upon versus vs v via vis-à-vis with
+          within without)
       }
 
       class << self

data/lib/citeproc/ruby/version.rb

@@ -1,5 +1,5 @@
 module CiteProc
   module Ruby
-    VERSION = '1.0.3'
+    VERSION = '1.0.4'
   end
 end

data/spec/citeproc/ruby/engine_spec.rb

@@ -10,21 +10,21 @@ module CiteProc
     let(:engine) { cp.engine }
 
     it 'registers itself as "citeproc-ruby"' do
-      CiteProc::Engine.available.should include('citeproc-ruby')
+      expect(CiteProc::Engine.available).to include('citeproc-ruby')
     end
 
     it 'is the default engine' do
-      CiteProc::Engine.default.should equal(CiteProc::Ruby::Engine)
-      engine.should be_a(CiteProc::Ruby::Engine)
+      expect(CiteProc::Engine.default).to equal(CiteProc::Ruby::Engine)
+      expect(engine).to be_a(CiteProc::Ruby::Engine)
     end
 
     describe '#bibliography' do
 
       describe 'when there are no items in the processor' do
         it 'returns an empty bibliography for any selector' do
-          cp.bibliography().should be_empty
-          cp.bibliography(:all => {}).should be_empty
-          cp.bibliography(:none => {}).should be_empty
+          expect(cp.bibliography()).to be_empty
+          expect(cp.bibliography(:all => {})).to be_empty
+          expect(cp.bibliography(:none => {})).to be_empty
         end
       end
 
@@ -43,24 +43,24 @@ module CiteProc
         end
 
         it 'renders the reference for the given id' do
-          cp.render(:bibliography, :id => 'grammatology').should == ['Derrida, J. (1976). Of Grammatology (corrected ed.). Baltimore: Johns Hopkins University Press.']
-          cp.render(:citation, :id => 'grammatology', :locator => '3-4').should == '(Derrida, 1976, pp. 3-4)'
-          cp.render(:bibliography, :id => 'knuth1968').should == ['Knuth, D. (1968). The art of computer programming (Vol. 1). Boston: Addison-Wesley.']
+          expect(cp.render(:bibliography, :id => 'grammatology')).to eq(['Derrida, J. (1976). Of Grammatology (corrected ed.). Baltimore: Johns Hopkins University Press.'])
+          expect(cp.render(:citation, :id => 'grammatology', :locator => '3-4')).to eq('(Derrida, 1976, pp. 3-4)')
+          expect(cp.render(:bibliography, :id => 'knuth1968')).to eq(['Knuth, D. (1968). The art of computer programming (Vol. 1). Boston: Addison-Wesley.'])
 
           node = cp.engine.style.macros['author']
           (node > 'names' > 'name')[:initialize] = 'false'
 
           cp.engine.format = 'html'
-          cp.render(:bibliography, :id => 'knuth1968').should == ['Knuth, Donald. (1968). <i>The art of computer programming</i> (Vol. 1). Boston: Addison-Wesley.']
+          expect(cp.render(:bibliography, :id => 'knuth1968')).to eq(['Knuth, Donald. (1968). <i>The art of computer programming</i> (Vol. 1). Boston: Addison-Wesley.'])
 
-          cp.render(:citation, :id => 'knuth1968', :locator => '23').should == '(Knuth, 1968, p. 23)'
+          expect(cp.render(:citation, :id => 'knuth1968', :locator => '23')).to eq('(Knuth, 1968, p. 23)')
         end
 
         it 'overrides locales if the processor option is set' do
-          cp.render(:bibliography, :id => 'difference').should == ['Derrida, J. (1967). L’écriture et la différence (1st ed.). Paris: Éditions du Seuil.']
+          expect(cp.render(:bibliography, :id => 'difference')).to eq(['Derrida, J. (1967). L’écriture et la différence (1st ed.). Paris: Éditions du Seuil.'])
 
           cp.options[:allow_locale_overrides] = true
-          cp.render(:bibliography, :id => 'difference').should == ['Derrida, J. (1967). L’écriture et la différence (1ʳᵉ éd.). Paris: Éditions du Seuil.']
+          expect(cp.render(:bibliography, :id => 'difference')).to eq(['Derrida, J. (1967). L’écriture et la différence (1ʳᵉ éd.). Paris: Éditions du Seuil.'])
         end
       end
     end
@@ -76,14 +76,14 @@ module CiteProc
         end
 
         it 'renders the citation for the given id' do
-          cp.process(:id => 'knuth1968', :locator => '23').should == '(Knuth, 1968, p. 23)'
+          expect(cp.process(:id => 'knuth1968', :locator => '23')).to eq('(Knuth, 1968, p. 23)')
         end
 
         it 'combines and sorts multiple cite items' do
-          cp.process([
+          expect(cp.process([
             {:id => 'knuth1968', :locator => '23'},
             {:id => 'grammatology', :locator => '11-14'}
-          ]).should == '(Derrida, 1976, pp. 11-14; Knuth, 1968, p. 23)'
+          ])).to eq('(Derrida, 1976, pp. 11-14; Knuth, 1968, p. 23)')
         end
       end
     end

data/spec/citeproc/ruby/formats/default_spec.rb

@@ -10,103 +10,103 @@ module CiteProc
       let(:node) { CSL::Style::Text.new }
 
       it 'returns an empty string if input is nil' do
-        format.apply(nil, node).should == ''
+        expect(format.apply(nil, node)).to eq('')
       end
 
       it 'returns the string unchanged if empty' do
         input = ''
-        format.apply(input, node).should be_equal(input)
-        input.should == ''
+        expect(format.apply(input, node)).to be_equal(input)
+        expect(input).to eq('')
       end
 
       it 'returns the string unchanged if node is nil' do
         input = 'foo'
-        format.apply(input, nil).should be_equal(input)
-        input.should == 'foo'
+        expect(format.apply(input, nil)).to be_equal(input)
+        expect(input).to eq('foo')
       end
 
       it 'supports localized quotes' do
         locale = double(:locale)
-        locale.stub(:punctuation_in_quotes?).and_return(true)
-        locale.stub(:quote).and_return('bar')
+        allow(locale).to receive(:punctuation_in_quotes?).and_return(true)
+        allow(locale).to receive(:quote).and_return('bar')
 
         node[:quotes] = true
 
-        format.apply('foo', node, locale).should == 'bar'
+        expect(format.apply('foo', node, locale)).to eq('bar')
       end
 
       it 'disregards localized closing quotes when squeezing affixes' do
         locale = double(:locale)
-        locale.stub(:punctuation_in_quotes?).and_return(true)
-        locale.stub(:quote) { |t| '"' << t << '"' }
-        locale.stub(:t) { |t| t == 'close-quote' ? '"' : "'" }
+        allow(locale).to receive(:punctuation_in_quotes?).and_return(true)
+        allow(locale).to receive(:quote) { |t| '"' << t << '"' }
+        allow(locale).to receive(:t) { |t| t == 'close-quote' ? '"' : "'" }
 
         node[:quotes] = true
         node[:suffix] = '.'
 
-        format.apply('foo', node, locale).should == '"foo."'
-        format.apply("'foo'", node, locale).should == "\"'foo.'\""
+        expect(format.apply('foo', node, locale)).to eq('"foo."')
+        expect(format.apply("'foo'", node, locale)).to eq("\"'foo.'\"")
       end
 
       describe 'text-case formats' do
         it 'supports lowercase' do
           node[:'text-case'] = 'lowercase'
-          format.apply('Foo BAR', node).should == 'foo bar'
+          expect(format.apply('Foo BAR', node)).to eq('foo bar')
         end
 
         it 'supports lowercase for non-ascii letters' do
           node[:'text-case'] = 'lowercase'
-          format.apply('SCHÖN!', node).should == 'schön!'
+          expect(format.apply('SCHÖN!', node)).to eq('schön!')
         end
 
         it 'supports uppercase' do
           node[:'text-case'] = 'uppercase'
-          format.apply('Foo BAR', node).should == 'FOO BAR'
+          expect(format.apply('Foo BAR', node)).to eq('FOO BAR')
         end
 
         it 'supports uppercase for non-ascii letters' do
           node[:'text-case'] = 'uppercase'
-          format.apply('schön!', node).should == 'SCHÖN!'
+          expect(format.apply('schön!', node)).to eq('SCHÖN!')
         end
 
         it 'does not alter the original string' do
           node[:'text-case'] = 'lowercase'
           input = 'fooBar'
 
-          format.apply(input, node).should == 'foobar'
-          input.should == 'fooBar'
+          expect(format.apply(input, node)).to eq('foobar')
+          expect(input).to eq('fooBar')
         end
 
         it 'supports capitalize-first' do
           node[:'text-case'] = 'capitalize-first'
 
-          format.apply('foo bar', node).should == 'Foo bar'
-          format.apply('Foo bar', node).should == 'Foo bar'
-          format.apply('!foo bar', node).should == '!Foo bar'
-          format.apply('én foo bar', node).should == 'Én foo bar'
+          expect(format.apply('foo bar', node)).to eq('Foo bar')
+          expect(format.apply('Foo bar', node)).to eq('Foo bar')
+          expect(format.apply('!foo bar', node)).to eq('!Foo bar')
+          expect(format.apply('én foo bar', node)).to eq('Én foo bar')
         end
 
         it 'supports capitalize-all' do
           node[:'text-case'] = 'capitalize-all'
 
-          format.apply('foo bar', node).should == 'Foo Bar'
-          format.apply('!foo bar', node).should == '!Foo Bar'
-          format.apply('én foo bar', node).should == 'Én Foo Bar'
+          expect(format.apply('foo bar', node)).to eq('Foo Bar')
+          expect(format.apply('!foo bar', node)).to eq('!Foo Bar')
+          expect(format.apply('én foo bar', node)).to eq('Én Foo Bar')
         end
 
         it 'supports sentence case' do
           node[:'text-case'] = 'sentence'
 
-          format.apply('FOO bar', node).should == 'Foo bar'
-          format.apply('foo Bar BAR', node).should == 'Foo Bar Bar'
-          format.apply('én Foo bar', node).should == 'Én Foo bar'
+          expect(format.apply('FOO bar', node)).to eq('Foo bar')
+          expect(format.apply('foo Bar BAR', node)).to eq('Foo Bar Bar')
+          expect(format.apply('én Foo bar', node)).to eq('Én Foo bar')
         end
 
         it 'supports title case' do
           node[:'text-case'] = 'title'
 
-          format.apply('The adventures of Huckleberry Finn', node).should == 'The Adventures of Huckleberry Finn'
-          format.apply("This IS a pen that is a smith pencil", node).should == 'This IS a Pen That Is a Smith Pencil'
+          expect(format.apply('The adventures of Huckleberry Finn', node)).to eq('The Adventures of Huckleberry Finn')
+          expect(format.apply("This IS a pen that is a smith pencil", node)).to eq('This IS a Pen That Is a Smith Pencil')
           #format.apply('of mice and men', node).should == 'Of Mice And Men'
         end
       end
@@ -115,15 +115,15 @@ module CiteProc
         before { node[:'strip-periods'] = true }
 
         it 'strips all periods from the output' do
-          format.apply('hello there...! how.are.you?', node).should == 'hello there! howareyou?'
-          format.apply('foo bar!', node).should == 'foo bar!'
+          expect(format.apply('hello there...! how.are.you?', node)).to eq('hello there! howareyou?')
+          expect(format.apply('foo bar!', node)).to eq('foo bar!')
         end
 
         it 'does not strip periods from affixes' do
           node[:prefix] = '...('
           node[:suffix] = ').'
 
-          format.apply('foo.bar.', node).should == '...(foobar).'
+          expect(format.apply('foo.bar.', node)).to eq('...(foobar).')
         end
       end
 
@@ -133,24 +133,24 @@ module CiteProc
           node[:suffix] = 'ooo'
           node[:'text-case'] = 'uppercase'
 
-          format.apply('ooo', node).should == 'fooOOOooo'
+          expect(format.apply('ooo', node)).to eq('fooOOOooo')
         end
 
         it 'drop squeezable characters at start/end' do
           node[:suffix] = ' '
 
-          format.apply('foo', node).should == 'foo '
-          format.apply('foo ', node).should == 'foo '
+          expect(format.apply('foo', node)).to eq('foo ')
+          expect(format.apply('foo ', node)).to eq('foo ')
 
           node[:suffix] = '. '
-          format.apply('foo', node).should == 'foo. '
-          format.apply('foo.', node).should == 'foo. '
-          format.apply('foo?', node).should == 'foo? '
+          expect(format.apply('foo', node)).to eq('foo. ')
+          expect(format.apply('foo.', node)).to eq('foo. ')
+          expect(format.apply('foo?', node)).to eq('foo? ')
 
           node[:prefix] = '.'
-          format.apply('foo', node).should == '.foo. '
-          format.apply('.foo', node).should == '.foo. '
-          format.apply(',foo', node).should == '.,foo. '
+          expect(format.apply('foo', node)).to eq('.foo. ')
+          expect(format.apply('.foo', node)).to eq('.foo. ')
+          expect(format.apply(',foo', node)).to eq('.,foo. ')
         end
       end
     end

data/spec/citeproc/ruby/formats/html_spec.rb

@@ -5,7 +5,7 @@ module CiteProc
 
     describe 'Formats::Html' do
       it 'can be created with an options hash' do
-        Formats::Html.new(:css_only => true).should be_css_only
+        expect(Formats::Html.new(:css_only => true)).to be_css_only
       end
     end
 
@@ -16,20 +16,20 @@ module CiteProc
       describe 'text-case formats' do
         it 'supports lowercase' do
           node[:'text-case'] = 'lowercase'
-          format.apply('Foo BAR', node).should == 'foo bar'
+          expect(format.apply('Foo BAR', node)).to eq('foo bar')
         end
       end
 
       describe 'entity escaping' do
         it 'escapes entities in the original text' do
           node[:'text-case'] = 'lowercase'
-          format.apply('Foo & BAR', node).should == 'foo & bar'
+          expect(format.apply('Foo & BAR', node)).to eq('foo & bar')
         end
 
         it 'escapes entities in affixes' do
           node[:prefix] = '<'
           node[:suffix] = '>'
-          format.apply('foo', node).should == '&lt;foo&gt;'
+          expect(format.apply('foo', node)).to eq('&lt;foo&gt;')
         end
 
         it 'escapes entities in quotes' do
@@ -38,7 +38,7 @@ module CiteProc
           locale.store 'close-quote', '>'
 
           node[:quotes] = true
-          format.apply('foo', node, locale).should == '&lt;foo&gt;'
+          expect(format.apply('foo', node, locale)).to eq('&lt;foo&gt;')
         end
       end
 
@@ -48,7 +48,7 @@ module CiteProc
           node[:suffix] = 'ooo'
           node[:'font-style'] = 'italic'
 
-          format.apply('ooo', node).should == 'foo<i>ooo</i>ooo'
+          expect(format.apply('ooo', node)).to eq('foo<i>ooo</i>ooo')
         end
 
         it 'are added before text formats have been applied for layout nodes' do
@@ -58,7 +58,7 @@ module CiteProc
           layout[:suffix] = 'ooo'
           layout[:'font-style'] = 'italic'
 
-          format.apply('ooo', layout).should == '<i>foooooooo</i>'
+          expect(format.apply('ooo', layout)).to eq('<i>foooooooo</i>')
         end
       end
 
@@ -66,69 +66,69 @@ module CiteProc
         it 'supports italic in both modes' do
           node[:'font-style'] = 'italic'
 
-          format.apply('foo bar', node).should == '<i>foo bar</i>'
+          expect(format.apply('foo bar', node)).to eq('<i>foo bar</i>')
 
           format.config[:italic] = 'em'
-          format.apply('foo bar', node).should == '<em>foo bar</em>'
+          expect(format.apply('foo bar', node)).to eq('<em>foo bar</em>')
 
           format.config[:css_only] = true
-          format.apply('foo bar', node).should == '<span style="font-style: italic">foo bar</span>'
+          expect(format.apply('foo bar', node)).to eq('<span style="font-style: italic">foo bar</span>')
         end
 
         it 'supports normal and oblique via css' do
           node[:'font-style'] = 'oblique'
-          format.apply('foo bar', node).should == '<span style="font-style: oblique">foo bar</span>'
+          expect(format.apply('foo bar', node)).to eq('<span style="font-style: oblique">foo bar</span>')
 
           node[:'font-style'] = 'normal'
-          format.apply('foo bar', node).should == '<span style="font-style: normal">foo bar</span>'
+          expect(format.apply('foo bar', node)).to eq('<span style="font-style: normal">foo bar</span>')
         end
       end
 
       it 'supports font-variant via css' do
         node[:'font-variant'] = 'small-caps'
-        format.apply('foo bar', node).should == '<span style="font-variant: small-caps">foo bar</span>'
+        expect(format.apply('foo bar', node)).to eq('<span style="font-variant: small-caps">foo bar</span>')
       end
 
       describe 'font-weight' do
         it 'supports bold in both modes' do
           node[:'font-weight'] = 'bold'
 
-          format.apply('foo bar', node).should == '<b>foo bar</b>'
+          expect(format.apply('foo bar', node)).to eq('<b>foo bar</b>')
 
           format.config[:bold] = 'strong'
-          format.apply('foo bar', node).should == '<strong>foo bar</strong>'
+          expect(format.apply('foo bar', node)).to eq('<strong>foo bar</strong>')
 
           format.config[:css_only] = true
-          format.apply('foo bar', node).should == '<span style="font-weight: bold">foo bar</span>'
+          expect(format.apply('foo bar', node)).to eq('<span style="font-weight: bold">foo bar</span>')
         end
 
         it 'supports normal and light via css' do
           node[:'font-weight'] = 'light'
-          format.apply('foo bar', node).should == '<span style="font-weight: light">foo bar</span>'
+          expect(format.apply('foo bar', node)).to eq('<span style="font-weight: light">foo bar</span>')
 
           node[:'font-weight'] = 'normal'
-          format.apply('foo bar', node).should == '<span style="font-weight: normal">foo bar</span>'
+          expect(format.apply('foo bar', node)).to eq('<span style="font-weight: normal">foo bar</span>')
         end
       end
 
       it 'supports text-decoration via css' do
         node[:'text-decoration'] = 'underline'
-        format.apply('foo bar', node).should == '<span style="text-decoration: underline">foo bar</span>'
+        expect(format.apply('foo bar', node)).to eq('<span style="text-decoration: underline">foo bar</span>')
       end
 
       it 'supports vertical-align via css' do
         node[:'vertical-align'] = 'sup'
-        format.apply('foo bar', node).should == '<span style="vertical-align: sup">foo bar</span>'
+        expect(format.apply('foo bar', node)).to eq('<span style="vertical-align: sup">foo bar</span>')
       end
 
       describe 'display' do
         it 'is supported in an outer container' do
           node[:'display'] = 'block'
           node[:'text-decoration'] = 'underline'
-          format.apply('foo bar', node).should == '<div class="csl-block"><span style="text-decoration: underline">foo bar</span></div>'
+          expect(format.apply('foo bar', node)).to eq('<div class="csl-block"><span style="text-decoration: underline">foo bar</span></div>')
 
           node[:prefix] = '('
-          format.apply('foo bar', node).should == '<div class="csl-block">(<span style="text-decoration: underline">foo bar</span></div>'
+          expect(format.apply('foo bar', node)).to eq('<div class="csl-block">(<span style="text-decoration: underline">foo bar</span></div>')
         end
       end
 
@@ -143,7 +143,7 @@ module CiteProc
         it 'can be applied' do
           format.config[:bib_indent] = nil
           format.bibliography(bibliography)
-          bibliography.join.should == '<ol class="csl-bibliography"><li class="csl-entry">foo</li><li class="csl-entry">bar</li></ol>'
+          expect(bibliography.join).to eq('<ol class="csl-bibliography"><li class="csl-entry">foo</li><li class="csl-entry">bar</li></ol>')
         end
 
         it 'can be customized' do
@@ -153,7 +153,7 @@ module CiteProc
           format.config[:bib_container] = 'div'
 
           format.bibliography(bibliography)
-          bibliography.join.should == '<div class="csl-bibliography"><span>foo</span><span>bar</span></div>'
+          expect(bibliography.join).to eq('<div class="csl-bibliography"><span>foo</span><span>bar</span></div>')
         end
       end
     end