csl 1.2.1 → 1.2.2

data/spec/csl/locale/date_spec.rb

@@ -6,15 +6,15 @@ module CSL
   
     let(:date) { Locale::Date.new }
     
-    it { should_not be_nil }
+    it { is_expected.not_to be_nil }
     
-    it { should be_text }
-    it { should_not be_numeric }
+    it { is_expected.to be_text }
+    it { is_expected.not_to be_numeric }
   
     describe '#parts' do
       
       it 'returns nil by default' do
-        date.parts.should be_empty
+        expect(date.parts).to be_empty
       end
       
     end
@@ -22,11 +22,11 @@ module CSL
     describe '#to_xml' do
       
       it 'returns <date/> by default' do
-        Locale::Date.new.to_xml.should == '<date/>'
+        expect(Locale::Date.new.to_xml).to eq('<date/>')
       end
 
       it 'returns <date form="numeric"/> for an empty numeric date' do
-        Locale::Date.new(:form => 'numeric').to_xml.should == '<date form="numeric"/>'
+        expect(Locale::Date.new(:form => 'numeric').to_xml).to eq('<date form="numeric"/>')
       end
       
     end
@@ -35,24 +35,24 @@ module CSL
 
   describe Locale::DatePart do
 
-    it { should_not be_nil }
+    it { is_expected.not_to be_nil }
     
-    it { should_not be_day }
-    it { should_not be_month }
-    it { should_not be_year }
+    it { is_expected.not_to be_day }
+    it { is_expected.not_to be_month }
+    it { is_expected.not_to be_year }
   
     describe '#to_xml' do
       
       it 'returns <date-part/> by default' do
-        Locale::DatePart.new.to_xml.should == "<date-part/>"
+        expect(Locale::DatePart.new.to_xml).to eq("<date-part/>")
       end
       
       it 'returns <date-part name="year"/> when the name is "year"' do
-        Locale::DatePart.new(:name => 'year').to_xml.should == '<date-part name="year"/>'
+        expect(Locale::DatePart.new(:name => 'year').to_xml).to eq('<date-part name="year"/>')
       end
       
       it 'returns <date-part name="month" form="numeric" prefix="-"/> for a numeric month with prefix "-"' do
-        Locale::DatePart.new(:name => 'month', :form => 'numeric', :prefix => '-').to_xml.should match(/(\s(name|form|prefix)="[^"]+"){3}/)
+        expect(Locale::DatePart.new(:name => 'month', :form => 'numeric', :prefix => '-').to_xml).to match(/(\s(name|form|prefix)="[^"]+"){3}/)
       end
       
     end

data/spec/csl/locale/style_options_spec.rb

@@ -3,15 +3,15 @@ require 'spec_helper'
 module CSL  
   describe Locale::StyleOptions do
   
-    it { should_not be nil }
+    it { is_expected.not_to be nil }
     
     it 'punctuation-in-quote is false by default' do
-      subject[:'punctuation-in-quote'].should be false
+      expect(subject[:'punctuation-in-quote']).to be false
     end
     
     describe '#to_xml' do
       it 'returns <style-options punctuation-in-quote="false"/> by default' do
-        subject.to_xml.should =~ /<style-options\/>/
+        expect(subject.to_xml).to match(/<style-options\/>/)
       end
     end
     

data/spec/csl/locale/term_spec.rb

@@ -4,17 +4,17 @@ require 'spec_helper'
 module CSL
   describe Locale::Terms do
 
-    it { should_not be nil }
+    it { is_expected.not_to be nil }
 
     describe '#to_xml' do
       it 'returns <terms/> by default' do
-        subject.to_xml.should == '<terms/>'
+        expect(subject.to_xml).to eq('<terms/>')
       end
     end
 
     describe '.specialize' do
       it 'filters the passed in hash to contain only match-able entries' do
-        Locale::Term.specialize({ :form => 'short', :foo => 'bar' }).should == { :form => 'short' }
+        expect(Locale::Term.specialize({ :form => 'short', :foo => 'bar' })).to eq({ :form => 'short' })
       end
     end
 
@@ -39,7 +39,7 @@ module CSL
           ordinal ordinal-01 ordinal-02 ordinal-03 ordinal
         }.each_with_index do |ordinal, number|
           it "returns #{ordinal.inspect} for #{number}" do
-            en.ordinalize(number)[:name].should == ordinal
+            expect(en.ordinalize(number)[:name]).to eq(ordinal)
           end
         end
       end
@@ -84,32 +84,32 @@ module CSL
         end
 
         it 'returns nil if there is no matching term' do
-          en.lookup(:foo).should be_nil
+          expect(en.lookup(:foo)).to be_nil
         end
 
         it 'returns the long form by default' do
-          en.lookup(:page).should be_long
+          expect(en.lookup(:page)).to be_long
         end
 
         it 'returns the term in the passed-in form if available' do
-          en.lookup(:section, :form => 'long').should be_long
-          en.lookup(:section, :form => 'short').should be_short
-          en.lookup(:section, :form => 'symbol').should be_symbol
+          expect(en.lookup(:section, :form => 'long')).to be_long
+          expect(en.lookup(:section, :form => 'short')).to be_short
+          expect(en.lookup(:section, :form => 'symbol')).to be_symbol
 
-          en.lookup(:editor).should be_long
-          en.lookup(:editor, :form => 'long').should be_long
-          en.lookup(:editor, :form => 'verb').should be_verb
-          en.lookup(:editor, :form => 'verb-short').should be_verb_short
+          expect(en.lookup(:editor)).to be_long
+          expect(en.lookup(:editor, :form => 'long')).to be_long
+          expect(en.lookup(:editor, :form => 'verb')).to be_verb
+          expect(en.lookup(:editor, :form => 'verb-short')).to be_verb_short
         end
 
         it 'returns the right fallback form if the passed-in form is not available' do
-          en.lookup(:page, :form => 'verb').should be_long
-          en.lookup(:page, :form => 'verb-short').should be_long
-          en.lookup(:page, :form => 'symbol').should be_short
+          expect(en.lookup(:page, :form => 'verb')).to be_long
+          expect(en.lookup(:page, :form => 'verb-short')).to be_long
+          expect(en.lookup(:page, :form => 'symbol')).to be_short
         end
 
         it 'ignores irrelevant options' do
-          en.lookup(:page, :plural => true).should_not be_nil
+          expect(en.lookup(:page, :plural => true)).not_to be_nil
         end
       end
 
@@ -118,23 +118,23 @@ module CSL
 
   describe Locale::Term do
 
-    it { should_not be_nil }
+    it { is_expected.not_to be_nil }
 
-    it { should_not be_gendered }
-    it { should be_neutral }
+    it { is_expected.not_to be_gendered }
+    it { is_expected.to be_neutral }
 
-    it { should be_long }
+    it { is_expected.to be_long }
 
-    it { should_not be_ordinal }
-    it { should_not be_short_ordinal }
-    it { should_not be_long_ordinal }
+    it { is_expected.not_to be_ordinal }
+    it { is_expected.not_to be_short_ordinal }
+    it { is_expected.not_to be_long_ordinal }
 
     it 'is not a textnode by default' do
-      subject.should_not be_textnode
+      expect(subject).not_to be_textnode
     end
 
     it 'is a textnode when the text is "foo"' do
-      Locale::Term.new { |t| t.text = 'foo' }.should be_textnode
+      expect(Locale::Term.new { |t| t.text = 'foo' }).to be_textnode
     end
 
     describe 'gender attribute is set' do
@@ -142,72 +142,72 @@ module CSL
       let(:f) { Locale::Term.new(:name => 'edition') { |t| t.feminine!; t.text = 'Ausgabe' } }
 
       it 'is gendered' do
-        m.should be_gendered
-        f.should be_gendered
+        expect(m).to be_gendered
+        expect(f).to be_gendered
       end
 
       it 'is feminine or masculine' do
-        m.should be_masculine
-        f.should be_feminine
+        expect(m).to be_masculine
+        expect(f).to be_feminine
       end
 
       it 'is not neutral' do
-        m.should_not be_neutral
-        f.should_not be_neutral
+        expect(m).not_to be_neutral
+        expect(f).not_to be_neutral
       end
 
       describe '#to_xml' do
         it 'contains the correct gender' do
-          m.to_xml.should =~ /gender="masculine"/
-          f.to_xml.should =~ /gender="feminine"/
+          expect(m.to_xml).to match(/gender="masculine"/)
+          expect(f.to_xml).to match(/gender="feminine"/)
         end
       end
 
       describe '#match?' do
         it 'matches the name when passed a string' do
-          m.should be_match(:name => 'month-05')
+          expect(m).to be_match(:name => 'month-05')
         end
 
         it 'matches the name when passed a pattern' do
-          m.should be_match(:name => /month-\d\d/)
+          expect(m).to be_match(:name => /month-\d\d/)
         end
 
         it 'matches when passed a matching hash without gender' do
-          f.should be_match(:name => 'edition')
+          expect(f).to be_match(:name => 'edition')
         end
 
         it 'does not match when passed a matching hash with wrong gender' do
-          f.matches?(:name => 'edition', :gender => 'masculine').should_not be_true
+          expect(f.matches?(:name => 'edition', :gender => 'masculine')).not_to be_truthy
         end
 
         it 'matches when passed a matching hash with matching gender' do
-          f.matches?(:name => 'edition', :gender => 'feminine').should be_true
+          expect(f.matches?(:name => 'edition', :gender => 'feminine')).to be_truthy
         end
       end
 
       describe '#exact_match?' do
         it 'does not match when passed a matching hash without gender' do
-          f.should_not be_exact_match(:name => 'edition')
+          expect(f).not_to be_exact_match(:name => 'edition')
         end
       end
 
       describe 'attributes#to_a' do
         it 'returns an array of all attribute values of underlying struct' do
-          f.attributes.to_a.should == ['edition', 'long', 'feminine', nil, nil]
+          expect(f.attributes.to_a).to eq(['edition', 'long', 'feminine', nil, nil])
         end
       end
     end
 
     describe '#to_s' do
       it 'returns an empty string by default' do
-        Locale::Term.new.to_s.should == ''
+        expect(Locale::Term.new.to_s).to eq('')
       end
 
       describe 'given a simple term' do
         let(:node) { Locale::Term.new { |t| t.text = 'foo' } }
 
         it "returns the term's text" do
-          node.to_s.should == node.text
+          expect(node.to_s).to eq(node.text)
         end
       end
 
@@ -215,23 +215,23 @@ module CSL
         let(:node) { Locale::Term.new { |t| t.single = 'shoe'; t.multiple = 'shoes' } }
 
         it "returns the term's singular form by default" do
-          node.to_s.should == node.singularize
+          expect(node.to_s).to eq(node.singularize)
         end
 
         it "returns the term's plural form when passed :number => :plural" do
-          node.to_s(:number => :plural).should == node.pluralize
+          expect(node.to_s(:number => :plural)).to eq(node.pluralize)
         end
 
         it "returns the term's plural form when passed :number => 2" do
-          node.to_s(:number => 2).should == node.pluralize
+          expect(node.to_s(:number => 2)).to eq(node.pluralize)
         end
 
         it "returns the term's singular form when passed :number => 1" do
-          node.to_s(:number => 1).should == node.singularize
+          expect(node.to_s(:number => 1)).to eq(node.singularize)
         end
 
         it "returns the term's plural form when passed :plural => true" do
-          node.to_s(:plural => true).should == node.pluralize
+          expect(node.to_s(:plural => true)).to eq(node.pluralize)
         end
 
       end
@@ -239,15 +239,15 @@ module CSL
 
     describe '#to_xml' do
       it 'returns <term/> by default' do
-        subject.to_xml.should == '<term/>'
+        expect(subject.to_xml).to eq('<term/>')
       end
 
       it 'returns <term>foo</term> when the text is "foo"' do
-        Locale::Term.new { |t| t.text = 'foo' }.to_xml.should == '<term>foo</term>'
+        expect(Locale::Term.new { |t| t.text = 'foo' }.to_xml).to eq('<term>foo</term>')
       end
 
       it 'returns <term><multiple>foo</multiple></term> when multiple is "foo"' do
-        Locale::Term.new { |t| t.multiple = 'foo' }.to_xml.should == '<term><multiple>foo</multiple></term>'
+        expect(Locale::Term.new { |t| t.multiple = 'foo' }.to_xml).to eq('<term><multiple>foo</multiple></term>')
       end
 
     end

data/spec/csl/locale_spec.rb

@@ -15,7 +15,7 @@ module CSL
     describe '.regions' do
 
       it 'returns the default region when passed a language symbol' do
-        Locale.regions[:en].should == :US
+        expect(Locale.regions[:en]).to eq(:US)
       end
 
     end
@@ -25,7 +25,7 @@ module CSL
       describe 'the language hash' do
         it 'returns the default language when passed a region string' do
           %w{ US en GB en AT de DE de }.map(&:to_sym).each_slice(2) do |region, language|
-            Locale.languages[region].should == language
+            expect(Locale.languages[region]).to eq(language)
           end
         end
       end
@@ -40,28 +40,28 @@ module CSL
         'de-AT' => 'de-AT'
       }.each_pair do |tag, expected|
         it "converts #{tag.inspect} to #{expected.inspect}" do
-          Locale.normalize(tag).should == expected
+          expect(Locale.normalize(tag)).to eq(expected)
         end
       end
     end
 
     describe '.new' do
-      it { should_not be_nil }
+      it { is_expected.not_to be_nil }
 
       it 'defaults to default language' do
-        Locale.new.language.should == Locale.default.split(/-/)[0].to_sym
+        expect(Locale.new.language).to eq(Locale.default.split(/-/)[0].to_sym)
       end
 
       it 'defaults to default region' do
-        Locale.new.region.should == Locale.default.split(/-/)[1].to_sym
+        expect(Locale.new.region).to eq(Locale.default.split(/-/)[1].to_sym)
       end
 
       it 'contains no dates by default' do
-        Locale.new.dates.should be_nil
+        expect(Locale.new.dates).to be_nil
       end
 
       it 'contains no terms by default' do
-        Locale.new.terms.should be_nil
+        expect(Locale.new.terms).to be_nil
       end
 
     end
@@ -72,15 +72,15 @@ module CSL
         let(:locale) { Locale.load('en-GB') }
 
         it 'the returned locale has the correct IETF tag' do
-          locale.to_s.should == 'en-GB'
+          expect(locale.to_s).to eq('en-GB')
         end
 
         it 'the locale has language :en' do
-          locale.language.should == :en
+          expect(locale.language).to eq(:en)
         end
 
         it 'the locale has region :GB' do
-          locale.region.should == :GB
+          expect(locale.region).to eq(:GB)
         end
 
       end
@@ -91,17 +91,17 @@ module CSL
 
       it 'when passed "en-GB" sets language to :en and region to :GB' do
         locale.set('en-GB')
-        [locale.language, locale.region].should == [:en, :GB]
+        expect([locale.language, locale.region]).to eq([:en, :GB])
       end
 
       it 'when passed "de" sets language to :de and region to :DE' do
         locale.set('de')
-        [locale.language, locale.region].should == [:de, :DE]
+        expect([locale.language, locale.region]).to eq([:de, :DE])
       end
 
       it 'when passed "-AT" sets language to :de and region to :AT' do
         locale.set('-AT')
-        [locale.language, locale.region].should == [:de, :AT]
+        expect([locale.language, locale.region]).to eq([:de, :AT])
       end
 
     end
@@ -115,11 +115,11 @@ module CSL
         end
 
         it 'creates a duplicate option element if the first locale has no options' do
-          locale.should_not have_options
+          expect(locale).not_to have_options
           locale.merge!(locale_with_options)
-          locale.should have_options
-          locale.options[:foo].should == 'bar'
-          locale.options.should_not equal(locale_with_options.options)
+          expect(locale).to have_options
+          expect(locale.options[:foo]).to eq('bar')
+          expect(locale.options).not_to equal(locale_with_options.options)
         end
 
         it 'merges the options if both locales have options' do
@@ -127,15 +127,15 @@ module CSL
 
           expect { locale.merge!(locale_with_options) }.not_to change { locale.options.object_id }
 
-          locale.options[:foo].should == 'bar'
-          locale.options[:bar].should == 'foo'
+          expect(locale.options[:foo]).to eq('bar')
+          expect(locale.options[:bar]).to eq('foo')
         end
 
         it 'overrides the options with those in the other locale' do
           locale << Locale::StyleOptions.new(:bar => 'foo', :foo => 'foo')
           locale.merge!(locale_with_options)
-          locale.options[:foo].should == 'bar'
-          locale.options[:bar].should == 'foo'
+          expect(locale.options[:foo]).to eq('bar')
+          expect(locale.options[:bar]).to eq('foo')
         end
       end
 
@@ -146,19 +146,19 @@ module CSL
 
         it 'creates duplicate date elements if the first locale has no options' do
           locale.merge!(Locale.load('en-US'))
-          locale.should have_dates
+          expect(locale).to have_dates
         end
       end
     end
 
     describe '#legacy?' do
       it 'returns false by default' do
-        locale.should_not be_legacy
+        expect(locale).not_to be_legacy
       end
 
       it 'returns true if the version is less than 1.0.1' do
         locale.version = '0.8'
-        locale.should be_legacy
+        expect(locale).to be_legacy
       end
     end
 
@@ -168,30 +168,30 @@ module CSL
         locale.store 'open-quote', '»'
         locale.store 'close-quote', '«'
 
-        locale.quote('foo').should == '»foo«'
+        expect(locale.quote('foo')).to eq('»foo«')
       end
 
       it 'does not alter the string if there are no quotes in the locale' do
-        locale.quote('foo').should == 'foo'
+        expect(locale.quote('foo')).to eq('foo')
       end
 
       it 'adds quotes inside final punctuation if punctuation-in-quote option is set' do
         locale.store 'open-quote', '»'
         locale.store 'close-quote', '«'
 
-        locale.quote('foo.').should == '»foo«.'
-        locale.quote('foo,').should == '»foo«,'
+        expect(locale.quote('foo.')).to eq('»foo«.')
+        expect(locale.quote('foo,')).to eq('»foo«,')
 
-        locale.quote('foo!').should == '»foo!«'
-        locale.quote('foo?').should == '»foo?«'
+        expect(locale.quote('foo!')).to eq('»foo!«')
+        expect(locale.quote('foo?')).to eq('»foo?«')
 
         locale.punctuation_in_quotes!
 
-        locale.quote('foo.').should == '»foo.«'
-        locale.quote('foo,').should == '»foo,«'
+        expect(locale.quote('foo.')).to eq('»foo.«')
+        expect(locale.quote('foo,')).to eq('»foo,«')
 
-        locale.quote('foo!').should == '»foo!«'
-        locale.quote('foo?').should == '»foo?«'
+        expect(locale.quote('foo!')).to eq('»foo!«')
+        expect(locale.quote('foo?')).to eq('»foo?«')
       end
 
       it 'replaces existing quotes with inner quotes' do
@@ -200,7 +200,7 @@ module CSL
         locale.store 'open-inner-quote', '‘'
         locale.store 'close-inner-quote', '’'
 
-        locale.quote('“foo”').should == '“‘foo’”'
+        expect(locale.quote('“foo”')).to eq('“‘foo’”')
       end
     end
   end