citeproc 1.0.1 → 1.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: abde1189aaa24cbddc03302bf1dfddbf5cf16c4c
-  data.tar.gz: 166d801b807891e3c56f454ac9281209c2f50de2
+  metadata.gz: 66ce4e398cb9a4ab393a5f4baf0bbb08b54b053c
+  data.tar.gz: 222b8101e61b1aac744082a5155106cc15e49499
 SHA512:
-  metadata.gz: 8b5d32aebb7b02fb0703562db2c4959e96d1c76dd2b7444b0d2b43ee1a1652b4e0786ccbf0c90be1bd8aa042de1c80109f3d28acf0fcbb182d0cf20a11564b83
-  data.tar.gz: 2752f32474e7c1a51a718517e78c4200fb5f72505d4ed475597e99012213650e9c631344d1cc1c7a5a6c9b245788b356ebc298a785760fe9c6803d3e4e948165
+  metadata.gz: 07a7857820062116708c5f0716471016b065eafb460da34d07b8e401030fac0e5207e2b314a7cfbd1ca26caa53ccbf47ed7888d61831abb5454a13c80197d53a
+  data.tar.gz: c67fcd016def1e8664b42651848549ab3fc2355e1945e5ac6f8e5c260a2c2db152057828729be5903fd60ffd1548f8ab149155adcefe32f6c7a7b98f9aadba33

data/Gemfile

@@ -2,10 +2,16 @@ source 'https://rubygems.org'
 gemspec
 
 group :debug do
-  gem 'ruby-debug', :require => false, :platform => :jruby
-  gem 'debugger', '~>1.6', :require => false, :platform => :mri
-  gem 'rubinius-compiler', '~>2.0', :require => false, :platform => :rbx
-  gem 'rubinius-debugger', '~>2.0', :require => false, :platform => :rbx
+  if RUBY_VERSION >= '2.0'
+    gem 'byebug', :require => false, :platforms => :mri
+  else
+    gem 'debugger', :require => false, :platforms => :mri
+  end
+
+  gem 'ruby-debug', :require => false, :platforms => :jruby
+
+  gem 'rubinius-debugger', :require => false, :platforms => :rbx
+  gem 'rubinius-compiler', :require => false, :platforms => :rbx
 end
 
 group :optional do
@@ -30,7 +36,7 @@ end
 group :development do
   gem 'rake'
   gem 'cucumber'
-  gem 'rspec'
+  gem 'rspec', '~>2.0'
   gem 'simplecov', '~>0.8', :require => false
   gem 'rubinius-coverage', :platform => :rbx
   gem 'coveralls', :require => false

data/features/step_definitions/processor.rb

@@ -4,32 +4,32 @@ end
 
 Given(/^the following input:$/) do |string|
   @input = JSON.parse(string)
-  @input.should_not be_nil
+  expect(@input).not_to be_nil
 
   processor.import @input
 end
 
 Given(/^the following abbreviations:$/) do |string|
   processor.abbreviations = JSON.parse(string)
-  processor.abbreviations[:default].should_not be_empty
+  expect(processor.abbreviations[:default]).not_to be_empty
 end
 
 When(/^I render the entire bibliography$/) do
   @bibliography = processor.bibliography
-  @bibliography.errors.should == []
+  expect(@bibliography.errors).to eq([])
 end
 
 When(/^I render the following bibliography selection:$/) do |string|
   selection = JSON.parse(string)
-  selection.should_not be_nil
+  expect(selection).not_to be_nil
 
   @bibliography = processor.bibliography(selection)
-  @bibliography.errors.should == []
+  expect(@bibliography.errors).to eq([])
 end
 
 Then(/^the bibliography should be:$/) do |string|
   string.gsub!(/\n\s*/m, '') # strip newlines
-  @bibliography.join.should == string
+  expect(@bibliography.join).to eq(string)
 end
 
 When(/^I cite the following items:$/) do |string|
@@ -46,14 +46,14 @@ Then(/^the bibliography's options should match:$/) do |table|
   headers = table.headers.map(&:to_sym)
   expected = table.rows[0]
 
-  @bibliography.options.values_at(*headers).should == expected
+  expect(@bibliography.options.values_at(*headers)).to eq(expected)
 end
 
 Then(/^the results should be:$/) do |table|
-  @results.should == table.raw.map(&:first)
+  expect(@results).to eq(table.raw.map(&:first))
 end
 
 Then(/^the result should be:$/) do |string|
-  @result.should == string
+  expect(@result).to eq(string)
 end
 

data/features/support/env.rb

@@ -6,13 +6,15 @@ end
 
 begin
   case
-  when RUBY_PLATFORM < 'java'
-    require 'debug'
-    Debugger.start
+  when RUBY_PLATFORM == 'java'
+    # require 'debug'
+    # Debugger.start
   when defined?(RUBY_ENGINE) && RUBY_ENGINE == 'rbx'
     require 'rubinius/debugger'
-  else
+  when RUBY_VERSION < '2.0'
     require 'debugger'
+  else
+    require 'byebug'
   end
 rescue LoadError
   # ignore

data/lib/citeproc/item.rb

@@ -108,6 +108,11 @@ module CiteProc
       notify_observers :read, key, value
     end
 
+    def simulate_read_attribute(key, value)
+      changed
+      notify_observers :read, key, value
+    end
+
     alias original_read_attribute read_attribute
     alias unobservable_read_attribute read_attribute
 

data/lib/citeproc/version.rb

@@ -1,3 +1,3 @@
 module CiteProc
-  VERSION = '1.0.1'.freeze
+  VERSION = '1.0.2'.freeze
 end

data/spec/citeproc/abbreviate_spec.rb

@@ -11,8 +11,8 @@ module CiteProc
         let(:abbrev) { Hash[:foo, :bar] }
         it 'uses the hash as the new set of abbreviations' do
           subject.abbreviations = abbrev
-          subject.abbreviations.should == abbrev
-          subject.abbreviations.should_not equal(abbrev)
+          expect(subject.abbreviations).to eq(abbrev)
+          expect(subject.abbreviations).not_to equal(abbrev)
         end
       end
       
@@ -20,16 +20,16 @@ module CiteProc
         let(:abbrev) { '{"foo":"bar"}' }
         it 'uses the hash as the new set of abbreviations' do
           subject.abbreviations = abbrev
-          subject.abbreviations.should == Hash[:foo,'bar']
+          expect(subject.abbreviations).to eq(Hash[:foo,'bar'])
         end
       end
     end
     
     describe '#abbreviate' do
       it 'looks up abbreviations in the default namespace by default' do
-        subject.abbreviate(:title, 'foo').should == nil
+        expect(subject.abbreviate(:title, 'foo')).to eq(nil)
         subject.abbreviations[:default][:title] = { 'foo' => 'bar' }
-        subject.abbreviate(:title, 'foo').should == 'bar'
+        expect(subject.abbreviate(:title, 'foo')).to eq('bar')
       end
     end
     

data/spec/citeproc/assets_spec.rb

@@ -30,40 +30,40 @@ module CiteProc
 			end
 
 			it 'should not be open by default' do
-				Style.new.should_not be_open
+				expect(Style.new).not_to be_open
 			end
 			
 			describe '.open' do  
 
 				it 'accepts an absolute file name' do
-					Style.open(@file.path).to_s.should == "asset content\n"
+					expect(Style.open(@file.path).to_s).to eq("asset content\n")
 				end
 
 				it 'accepts a file name' do
-					Style.open(@name).to_s.should == "asset content\n"
+					expect(Style.open(@name).to_s).to eq("asset content\n")
 				end
 
 				it 'accepts a file name without extension' do
-					Style.open(@name.sub(/#{@extension}$/,'')).to_s.should == "asset content\n"
+					expect(Style.open(@name.sub(/#{@extension}$/,'')).to_s).to eq("asset content\n")
 				end
 
 
 				it 'accepts an io object' do
-					Style.open(@file.open).to_s.should == "asset content\n"
+					expect(Style.open(@file.open).to_s).to eq("asset content\n")
 				end
 
 				it 'returns the given string if it looks like XML' do
-					Style.open('<b>foo bar!</b>').to_s.should == '<b>foo bar!</b>'
+					expect(Style.open('<b>foo bar!</b>').to_s).to eq('<b>foo bar!</b>')
 				end
 			end
 
       describe '.extend_name' do
         it 'adds the default extension if the file does not already end with it' do
-          Style.extend_name(@name.sub(/#{@extension}$/,'')).should == @name
+          expect(Style.extend_name(@name.sub(/#{@extension}$/,''))).to eq(@name)
         end
         
         it 'does not add the default extension if the file already ends with it' do
-          Style.extend_name(@name).should == @name
+          expect(Style.extend_name(@name)).to eq(@name)
         end
       end
       

data/spec/citeproc/attributes_spec.rb

@@ -33,18 +33,18 @@ module CiteProc
       end
     
       it 'generates no other setters' do
-        lambda { A.new.some_other_value }.should raise_error
+        expect { A.new.some_other_value }.to raise_error
       end
     end
   
     describe '#merge' do    
     
       it 'merges non-existent values from other object' do
-        A.new.merge(other)[:foo].should == 'bar'
+        expect(A.new.merge(other)[:foo]).to eq('bar')
       end
     
       it 'does not overwrite existing values when merging other object' do
-        instance.merge(other)[:bar].should == 'foo'
+        expect(instance.merge(other)[:bar]).to eq('foo')
       end
     
     end

data/spec/citeproc/bibliography_spec.rb

@@ -10,29 +10,29 @@ module CiteProc
     describe '#to_citeproc conversion' do
 
       it 'returns an array' do
-        subject.to_citeproc.should be_a(Array)
+        expect(subject.to_citeproc).to be_a(Array)
       end
 
       it 'returns exactly two elements' do
-        subject.to_citeproc.should have(2).elements
+        expect(subject.to_citeproc.size).to eq(2)
       end
 
       it 'returns formatting options as the first element' do
-        subject.to_citeproc.first.should be_a(Hash)
+        expect(subject.to_citeproc.first).to be_a(Hash)
       end
 
       describe 'the formatting options' do
         let(:options) { subject.to_citeproc[0] }
 
         it 'contains a the error list' do
-          options.should have_key('bibliography_errors')
-          options['bibliography_errors'].should be_empty
+          expect(options).to have_key('bibliography_errors')
+          expect(options['bibliography_errors']).to be_empty
         end
 
       end
 
       it 'returns the list of references as the second element' do
-        subject.to_citeproc.last.should be_a(Array)
+        expect(subject.to_citeproc.last).to be_a(Array)
       end
 
     end
@@ -59,10 +59,10 @@ module CiteProc
 
       it 'parses citeproc/json strings' do
         b = Bibliography.create!(js)
-        b.should be_a(Bibliography)
-        b.should have(2).references
-        b.should_not have_errors
-        b.options[:'second-field-align'].should be true
+        expect(b).to be_a(Bibliography)
+        expect(b.references.size).to eq(2)
+        expect(b).not_to have_errors
+        expect(b.options[:'second-field-align']).to be true
       end
 
     end

data/spec/citeproc/citation_data_spec.rb

@@ -25,25 +25,25 @@ module CiteProc
       it { should be_empty }
 
       it 'has not been processed by default' do
-        CitationData.new.should_not be_processed
+        expect(CitationData.new).not_to be_processed
       end
 
       describe '.new' do
 
         it 'accepts a citeproc hash' do
           d = CitationData.new(hash)
-          d.should be_footnote
-          d.should_not be_empty
-          d[0].should be_a(CitationItem)
-          d.index.should == 1
+          expect(d).to be_footnote
+          expect(d).not_to be_empty
+          expect(d[0]).to be_a(CitationItem)
+          expect(d.index).to eq(1)
         end
 
         it 'accepts an array of items' do
-          CitationData.new([CitationItem.new(:id => 'id')]).should have(1).items
+          expect(CitationData.new([CitationItem.new(:id => 'id')]).items.size).to eq(1)
         end
 
         it 'accepts an array of hashes' do
-          CitationData.new([{:id => 'id'}])[0].should be_a(CitationItem)
+          expect(CitationData.new([{:id => 'id'}])[0]).to be_a(CitationItem)
         end
 
       end
@@ -51,7 +51,7 @@ module CiteProc
       describe '#to_citeproc' do
 
         it 'returns empty an empty/default citation data element by default' do
-          CitationData.new.to_citeproc.should == { 'citationItems' => [], 'properties' => { 'noteIndex' => 0}}
+          expect(CitationData.new.to_citeproc).to eq({ 'citationItems' => [], 'properties' => { 'noteIndex' => 0}})
         end
 
 
@@ -67,7 +67,7 @@ module CiteProc
       describe '.new' do
 
         it 'accepts a hash as input' do
-          CitationItem.new(:label => 'chapter').should have_label
+          expect(CitationItem.new(:label => 'chapter')).to have_label
         end
 
       end
@@ -75,15 +75,15 @@ module CiteProc
       describe '#to_citeproc' do
 
         it 'returns empty citation data by default' do
-          CitationItem.new.to_citeproc.should == {}
+          expect(CitationItem.new.to_citeproc).to eq({})
         end
 
         it 'returns a hash with stringified keys' do
-          CitationItem.new(:type => :article).to_citeproc.should have_key('type')
+          expect(CitationItem.new(:type => :article).to_citeproc).to have_key('type')
         end
 
         it 'returns a hash with stringified values' do
-          CitationItem.new(:type => :article).to_citeproc.should have_value('article')
+          expect(CitationItem.new(:type => :article).to_citeproc).to have_value('article')
         end
 
       end

data/spec/citeproc/date_spec.rb

@@ -10,31 +10,31 @@ module CiteProc
 
         describe 'sorting' do
           it 'treats [2003] as less than [2003,1]' do
-            DateParts.new(2003).should be < DateParts.new(2003,1)
+            expect(DateParts.new(2003)).to be < DateParts.new(2003,1)
           end
 
           it 'treats [1992,9,23] as less than [1993,8,22]' do
-            DateParts.new(1992,9,23).should be < DateParts.new(1993,8,22)
+            expect(DateParts.new(1992,9,23)).to be < DateParts.new(1993,8,22)
           end
 
           it 'treats [1992,9,23] as less than [1992,10,22]' do
-            DateParts.new(1992,9,23).should be < DateParts.new(1992,10,22)
+            expect(DateParts.new(1992,9,23)).to be < DateParts.new(1992,10,22)
           end
 
           it 'treats [1992,9,23] as less than [1992,9,24]' do
-            DateParts.new(1992,9,23).should be < DateParts.new(1992,9,24)
+            expect(DateParts.new(1992,9,23)).to be < DateParts.new(1992,9,24)
           end
 
           it 'treats [-50] as less than [-25]' do
-            DateParts.new(-50).should be < DateParts.new(-25)
+            expect(DateParts.new(-50)).to be < DateParts.new(-25)
           end
 
           it 'treats [-50] as less than [-50,12]' do
-            DateParts.new(-50).should be < DateParts.new(-50,12)
+            expect(DateParts.new(-50)).to be < DateParts.new(-50,12)
           end
 
           it 'treats [1994,1,23] as less than today' do
-            DateParts.new(1994,1,23).should be < ::Date.today
+            expect(DateParts.new(1994,1,23)).to be < ::Date.today
           end
         end
 
@@ -42,56 +42,56 @@ module CiteProc
           let(:date) { DateParts.new(1991,8,22) }
 
           it 'creates a copy that contains the same parts' do
-            date.dup.to_a.should == [1991,8,22]
+            expect(date.dup.to_a).to eq([1991,8,22])
           end
 
           it 'does not return self' do
-            date.dup.should_not equal(date)
-            date.dup.should == date
+            expect(date.dup).not_to equal(date)
+            expect(date.dup).to eq(date)
           end
         end
 
         describe '#update' do
           it 'accepts a hash' do
-            DateParts.new.update(:month => 2, :year => 80).to_a.should == [80,2,nil]
+            expect(DateParts.new.update(:month => 2, :year => 80).to_a).to eq([80,2,nil])
           end
 
           it 'accepts an array' do
-            DateParts.new.update([80,2]).to_a.should == [80,2,nil]
+            expect(DateParts.new.update([80,2]).to_a).to eq([80,2,nil])
           end
         end
 
         describe '#strftime' do
           it 'formats the date parts according to the format string' do
-            DateParts.new(1998,2,4).strftime('FOO %0m%0d%y').should == 'FOO 020498'
+            expect(DateParts.new(1998,2,4).strftime('FOO %0m%0d%y')).to eq('FOO 020498')
           end
         end
 
         describe 'to_citeproc' do
           it 'returns an empty list by default' do
-            DateParts.new.to_citeproc.should == []
+            expect(DateParts.new.to_citeproc).to eq([])
           end
 
           it 'returns a list with the year if only the year is set' do
-            DateParts.new(2001).to_citeproc.should == [2001]
+            expect(DateParts.new(2001).to_citeproc).to eq([2001])
           end
 
           it 'supports zero parts' do
-            DateParts.new(0,0).to_citeproc.should == [0,0]
+            expect(DateParts.new(0,0).to_citeproc).to eq([0,0])
           end
         end
 
         describe '#open?' do
           it 'returns false by default' do
-            DateParts.new.should_not be_open
+            expect(DateParts.new).not_to be_open
           end
 
           it 'returns false for [1999,8,24]' do
-            DateParts.new(1999, 8, 24).should_not be_open
+            expect(DateParts.new(1999, 8, 24)).not_to be_open
           end
 
           it 'returns true for [0]' do
-            DateParts.new(0).should be_open
+            expect(DateParts.new(0)).to be_open
           end
         end
       end
@@ -113,80 +113,80 @@ module CiteProc
 
     describe '.new' do
       it 'accepts a hash as input' do
-        Date.new(:literal => 'Summer').to_s.should == 'Summer'
+        expect(Date.new(:literal => 'Summer').to_s).to eq('Summer')
       end
 
       it 'accepts a hash as input and converts date parts' do
-        Date.new(:'date-parts' => [[2003,2]]).parts[0].should be_a(Date::DateParts)
+        expect(Date.new(:'date-parts' => [[2003,2]]).parts[0]).to be_a(Date::DateParts)
       end
 
       it 'accepts a fixnum and treats it as the year' do
-        Date.new(1666).year.should == 1666
+        expect(Date.new(1666).year).to eq(1666)
       end
 
       it 'accepts a date' do
-        Date.new(::Date.new(1980,4)).month.should == 4
+        expect(Date.new(::Date.new(1980,4)).month).to eq(4)
       end
 
       it 'accepts a date and creates date parts' do
-        Date.new(::Date.new(1980,4)).parts[0].to_citeproc.should == [1980,4,1]
+        expect(Date.new(::Date.new(1980,4)).parts[0].to_citeproc).to eq([1980,4,1])
       end
 
       it 'is empty by default' do
-        Date.new.should be_empty
+        expect(Date.new).to be_empty
       end
 
       it 'accepts date strings' do
-        Date.new('2009-03-19').day.should == 19
+        expect(Date.new('2009-03-19').day).to eq(19)
       end
 
       it 'accepts JSON strings' do
-        Date.new('{ "date-parts": [[2001,1,19]]}').day.should == 19
+        expect(Date.new('{ "date-parts": [[2001,1,19]]}').day).to eq(19)
       end
 
       it 'accepts date parts in an array' do
-        Date.new([2009,3]).month.should == 3
+        expect(Date.new([2009,3]).month).to eq(3)
       end
 
       it 'accepts ranges as an array' do
-        Date.new([[2009],[2012]]).should be_range
+        expect(Date.new([[2009],[2012]])).to be_range
       end
 
       it 'accepts year ranges' do
-        Date.new(2009..2012).should be_range
+        expect(Date.new(2009..2012)).to be_range
       end
 
       it 'accepts exclusive date ranges' do
-        Date.new(::Date.new(2009) ... ::Date.new(2011)).end_date.year.should == 2010
+        expect(Date.new(::Date.new(2009) ... ::Date.new(2011)).end_date.year).to eq(2010)
       end
 
       it 'accepts inclusive date ranges' do
-        Date.new(::Date.new(2009) .. ::Date.new(2011)).end_date.year.should == 2011
+        expect(Date.new(::Date.new(2009) .. ::Date.new(2011)).end_date.year).to eq(2011)
       end
 
       it 'accepts EDTF date strings' do
-        Date.new('2009?-03-19').should be_uncertain
+        expect(Date.new('2009?-03-19')).to be_uncertain
       end
 
       it 'accepts EDTF intervals' do
-        Date.new('2009-03-19/2010-11-21').parts.map(&:to_citeproc).should == [[2009,3,19],[2010,11,21]]
+        expect(Date.new('2009-03-19/2010-11-21').parts.map(&:to_citeproc)).to eq([[2009,3,19],[2010,11,21]])
       end
     end
 
 		describe '.parse' do
 			it 'returns nil by default' do
-				Date.parse('').should be nil
-				Date.parse(nil).should be nil
+				expect(Date.parse('')).to be nil
+				expect(Date.parse(nil)).to be nil
 			end
 
 			it 'parses date strings' do
-				Date.parse('2004-10-26').year.should == 2004
+				expect(Date.parse('2004-10-26').year).to eq(2004)
 			end
 		end
 
     describe '.create' do
       it 'should accept parameters and return a new instance' do
-        Date.create('date-parts' => [[2001, 1]]).year.should == 2001
+        expect(Date.create('date-parts' => [[2001, 1]]).year).to eq(2001)
       end
     end
 
@@ -194,12 +194,12 @@ module CiteProc
       let(:date) { Date.new([1991,8]) }
 
       it 'creates a copy that contains the same parts' do
-        date.dup.parts.map(&:to_citeproc).should == [[1991,8]]
+        expect(date.dup.parts.map(&:to_citeproc)).to eq([[1991,8]])
       end
 
       it 'copies uncertainty' do
-        date.dup.should_not be_uncertain
-        date.uncertain!.dup.should be_uncertain
+        expect(date.dup).not_to be_uncertain
+        expect(date.uncertain!.dup).to be_uncertain
       end
 
       it 'makes a deep copy of attributes' do
@@ -211,95 +211,95 @@ module CiteProc
       end
 
       it 'does not return self' do
-        date.dup.should_not equal(date)
-        date.dup.should == date
+        expect(date.dup).not_to equal(date)
+        expect(date.dup).to eq(date)
       end
     end
 
     describe 'literal dates' do
       it 'is not literal by default' do
-        Date.new.should_not be_literal
+        expect(Date.new).not_to be_literal
       end
 
       it 'is literal if it contains only a literal field' do
-        Date.create(:literal => 'foo').should be_literal
+        expect(Date.create(:literal => 'foo')).to be_literal
       end
 
       it 'is literal if it contains a literal field' do
-        Date.create('date-parts' => [[2000]], :literal => 'foo').should be_literal
+        expect(Date.create('date-parts' => [[2000]], :literal => 'foo')).to be_literal
       end
     end
 
     describe 'seasons' do
       it 'is no season by default' do
-        Date.new.should_not be_season
+        expect(Date.new).not_to be_season
       end
 
       it 'is a season if contains only a season field' do
-        Date.new(:season => 'Winter').should be_season
+        expect(Date.new(:season => 'Winter')).to be_season
       end
 
       it 'is a season if contains a season field' do
-        Date.new(:'date-parts' => [[2001]], :season => 'Winter').should be_season
+        expect(Date.new(:'date-parts' => [[2001]], :season => 'Winter')).to be_season
       end
     end
 
     describe 'uncertain dates' do
       it 'are uncertain' do
-        Date.new({ 'date-parts' => [[-225]], 'circa' => '1' }).should be_uncertain
-        Date.new { |d| d.parts = [[-225]]; d.uncertain! }.should_not be_certain
+        expect(Date.new({ 'date-parts' => [[-225]], 'circa' => '1' })).to be_uncertain
+        expect(Date.new { |d| d.parts = [[-225]]; d.uncertain! }).not_to be_certain
       end
 
       describe '#(un)certain!' do
         it 'returns self' do
-          ad2k.uncertain!.should equal(ad2k)
-          ad2k.certain!.should equal(ad2k)
+          expect(ad2k.uncertain!).to equal(ad2k)
+          expect(ad2k.certain!).to equal(ad2k)
         end
       end
     end
 
     describe 'sorting' do
       it 'dates with more date-parts will come after those with fewer parts' do
-        (ad2k < may  && may < first_of_may).should be true
+        expect(ad2k < may  && may < first_of_may).to be true
       end
 
       it 'negative years are sorted inversely' do
-        [ad50, bc100, bc50, ad100].sort.map(&:year).should == [-100, -50, 50, 100]
+        expect([ad50, bc100, bc50, ad100].sort.map(&:year)).to eq([-100, -50, 50, 100])
       end
 
       it 'can be compared to dates' do
-        ad50.should be < ::Date.new(50,2)
-        ad50.should be > ::Date.new(49)
+        expect(ad50).to be < ::Date.new(50,2)
+        expect(ad50).to be > ::Date.new(49)
       end
     end
 
     describe '#start_date' do
       it 'returns nil by default' do
-        Date.new.start_date.should be_nil
+        expect(Date.new.start_date).to be_nil
       end
 
       it 'returns a ruby date when date-parts are set' do
-        Date.new(1999).start_date.year.should == 1999
+        expect(Date.new(1999).start_date.year).to eq(1999)
       end
     end
 
     describe '#end_date' do
       it 'returns nil by default' do
-        Date.new.end_date.should be_nil
+        expect(Date.new.end_date).to be_nil
       end
 
       it 'returns nil when there is a single date-parts set' do
-        Date.new(1312).end_date.should be_nil
+        expect(Date.new(1312).end_date).to be_nil
       end
 
       it 'returns a ruby date when date-parts are a closed range' do
-        Date.new(1999..2000).end_date.year.should == 2000
+        expect(Date.new(1999..2000).end_date.year).to eq(2000)
       end
     end
 
     describe '#-@' do
       it 'inverts the year' do
-        (-ad50).should == bc50
+        expect(-ad50).to eq(bc50)
       end
     end
 
@@ -312,112 +312,112 @@ module CiteProc
 		describe 'b.c. and a.d.' do
 
 			it 'the year 993 is a.d.' do
-				Date.new(993).should be_ad
+				expect(Date.new(993)).to be_ad
 			end
 
 			it 'the year 1000 is not a.d.' do
-				Date.new(1000).should_not be_ad
+				expect(Date.new(1000)).not_to be_ad
 			end
 
 			it 'the year 993 is not b.c.' do
-				Date.new(993).should_not be_bc
+				expect(Date.new(993)).not_to be_bc
 			end
 
 			it 'the year 0 is a.d.' do
-				Date.new(0).should be_ad
+				expect(Date.new(0)).to be_ad
 			end
 
 			it 'the year 0 is not b.c.' do
-				Date.new(0).should_not be_bc
+				expect(Date.new(0)).not_to be_bc
 			end
 
 			it 'the year -33 is not a.d.' do
-				Date.new(-33).should_not be_ad
+				expect(Date.new(-33)).not_to be_ad
 			end
 
 			it 'the year -33 is b.c.' do
-				Date.new(-33).should be_bc
+				expect(Date.new(-33)).to be_bc
 			end
 
 			it 'today is not a.d.' do
-				Date.today.should_not be_ad
+				expect(Date.today).not_to be_ad
 			end
 
 			it 'today is not b.c.' do
-				Date.today.should_not be_bc
+				expect(Date.today).not_to be_bc
 			end
 
 			it 'the year 2000 is not a.d.' do
-				ad2k.should_not be_ad
+				expect(ad2k).not_to be_ad
 			end
 
 		end
 
 		describe '#empty?' do
 		  it 'returns true by default' do
-		    Date.new.should be_empty
+		    expect(Date.new).to be_empty
 		  end
 
 		  it 'returns true when it contains no date parts' do
-		    Date.new({}).should be_empty
+		    expect(Date.new({})).to be_empty
 		  end
 
 		  it 'returns false for today' do
-		    Date.today.should_not be_empty
+		    expect(Date.today).not_to be_empty
 		  end
 
 		  it 'returns false for literal dates' do
-		    Date.new(:literal => 'foo').should_not be_empty
+		    expect(Date.new(:literal => 'foo')).not_to be_empty
 		  end
 
 		  it 'returns false for seasons' do
-		    Date.new(:season => 'Summer').should_not be_empty
+		    expect(Date.new(:season => 'Summer')).not_to be_empty
 		  end
 		end
 
     describe '#to_json' do
       it 'supports simple parts' do
-        Date.new(%w{2000 1 15}).to_json.should == '{"date-parts":[[2000,1,15]]}'
+        expect(Date.new(%w{2000 1 15}).to_json).to eq('{"date-parts":[[2000,1,15]]}')
       end
 
       it 'supports string parts' do
-        Date.new(['2000', '1', '15']).to_json.should == '{"date-parts":[[2000,1,15]]}'
+        expect(Date.new(['2000', '1', '15']).to_json).to eq('{"date-parts":[[2000,1,15]]}')
       end
 
       it 'supports integer parts' do
-        Date.new([2000, 1, 15]).to_json.should == '{"date-parts":[[2000,1,15]]}'
+        expect(Date.new([2000, 1, 15]).to_json).to eq('{"date-parts":[[2000,1,15]]}')
       end
 
       it 'supports mixed parts' do
-        Date.new(['2000', 1, '15']).to_json.should == '{"date-parts":[[2000,1,15]]}'
+        expect(Date.new(['2000', 1, '15']).to_json).to eq('{"date-parts":[[2000,1,15]]}')
       end
 
       it 'supports negative years' do
-        Date.new(-200).to_json.should == '{"date-parts":[[-200]]}'
+        expect(Date.new(-200).to_json).to eq('{"date-parts":[[-200]]}')
       end
 
       it 'treats seasons as a strings' do
-        Date.create({:season => '1', 'date-parts' => [[1950]]}).to_json.should =~ /"season":"1"/
+        expect(Date.create({:season => '1', 'date-parts' => [[1950]]}).to_json).to match(/"season":"1"/)
       end
 
       it 'supports seasons' do
-        Date.create({:season => 'Trinity', 'date-parts' => [[1975]]}).to_json.should =~ /"season":"Trinity"/
+        expect(Date.create({:season => 'Trinity', 'date-parts' => [[1975]]}).to_json).to match(/"season":"Trinity"/)
       end
 
       it 'supports string literals' do
-        Date.new(:literal => '13th century').to_json.should == '{"literal":"13th century"}'
+        expect(Date.new(:literal => '13th century').to_json).to eq('{"literal":"13th century"}')
       end
 
       it 'supports raw strings' do
-        Date.new(:raw => '23 May 1955').to_json.should == '{"date-parts":[[1955,5,23]]}'
+        expect(Date.new(:raw => '23 May 1955').to_json).to eq('{"date-parts":[[1955,5,23]]}')
       end
 
       it 'supports closed ranges' do
-        Date.new([[2000,11],[2000,12]]).to_json.should == '{"date-parts":[[2000,11],[2000,12]]}'
+        expect(Date.new([[2000,11],[2000,12]]).to_json).to eq('{"date-parts":[[2000,11],[2000,12]]}')
       end
 
       it 'supports open ranges' do
-        Date.new([[2000,11],[0,0]]).to_json.should == '{"date-parts":[[2000,11],[0,0]]}'
+        expect(Date.new([[2000,11],[0,0]]).to_json).to eq('{"date-parts":[[2000,11],[0,0]]}')
       end
     end