r18n-core 1.1.11 → 2.0.0

data/spec/i18n_spec.rb

@@ -1,4 +1,3 @@
-# encoding: utf-8
 require File.expand_path('../spec_helper', __FILE__)
 
 describe R18n::I18n do
@@ -13,31 +12,31 @@ describe R18n::I18n do
   end
 
   it "parses HTTP_ACCEPT_LANGUAGE" do
-    R18n::I18n.parse_http(nil).should == []
-    R18n::I18n.parse_http('').should == []
-    R18n::I18n.parse_http('ru,en;q=0.9').should == ['ru', 'en']
-    R18n::I18n.parse_http('ru;q=0.8,en;q=0.9').should == ['en', 'ru']
+    expect(R18n::I18n.parse_http(nil)).to eq([])
+    expect(R18n::I18n.parse_http('')).to eq([])
+    expect(R18n::I18n.parse_http('ru,en;q=0.9')).to eq(['ru', 'en'])
+    expect(R18n::I18n.parse_http('ru;q=0.8,en;q=0.9')).to eq(['en', 'ru'])
   end
 
   it "has default locale" do
     R18n::I18n.default = 'ru'
-    R18n::I18n.default.should == 'ru'
+    expect(R18n::I18n.default).to eq('ru')
   end
 
   it "loads locales" do
     i18n = R18n::I18n.new('en', DIR)
-    i18n.locales.should == [R18n.locale('en')]
+    expect(i18n.locales).to eq([R18n.locale('en')])
 
     i18n = R18n::I18n.new(['ru', 'nolocale-DL'], DIR)
-    i18n.locales.should == [R18n.locale('ru'),
+    expect(i18n.locales).to eq([R18n.locale('ru'),
                             R18n::UnsupportedLocale.new('nolocale-DL'),
                             R18n::UnsupportedLocale.new('nolocale'),
-                            R18n.locale('en')]
+                            R18n.locale('en')])
   end
 
   it "returns translations loaders" do
     i18n = R18n::I18n.new('en', DIR)
-    i18n.translation_places.should == [R18n::Loader::YAML.new(DIR)]
+    expect(i18n.translation_places).to eq([R18n::Loader::YAML.new(DIR)])
   end
 
   it "loads translations by loader" do
@@ -45,7 +44,7 @@ describe R18n::I18n do
       def available; [R18n.locale('en')]; end
       def load(locale); { 'custom' => 'Custom' }; end
     end
-    R18n::I18n.new('en', loader.new).custom.should == 'Custom'
+    expect(R18n::I18n.new('en', loader.new).custom).to eq('Custom')
   end
 
   it "passes parameters to default loader" do
@@ -55,129 +54,129 @@ describe R18n::I18n do
       def load(locale); { 'custom' => @param }; end
     end
     R18n.default_loader = loader
-    R18n::I18n.new('en', 'default').custom.should == 'default'
+    expect(R18n::I18n.new('en', 'default').custom).to eq('default')
   end
 
   it "loads translations" do
     i18n = R18n::I18n.new(['ru', 'en'], DIR)
-    i18n.one.should    == 'Один'
-    i18n[:one].should  == 'Один'
-    i18n['one'].should == 'Один'
-    i18n.only.english.should == 'Only in English'
+    expect(i18n.one).to    eq('Один')
+    expect(i18n[:one]).to  eq('Один')
+    expect(i18n['one']).to eq('Один')
+    expect(i18n.only.english).to eq('Only in English')
   end
 
   it "loads translations from several dirs" do
     i18n = R18n::I18n.new(['nolocale', 'en'], [TWO, DIR])
-    i18n.in.two.should == 'Two'
-    i18n.in.another.level.should == 'Hierarchical'
+    expect(i18n.in.two).to eq('Two')
+    expect(i18n.in.another.level).to eq('Hierarchical')
   end
 
   it "uses extension places" do
     R18n.extension_places << EXT
 
     i18n = R18n::I18n.new('en', DIR)
-    i18n.ext.should == 'Extension'
-    i18n.one.should == 'One'
+    expect(i18n.ext).to eq('Extension')
+    expect(i18n.one).to eq('One')
   end
 
   it "doesn't use extension without app translations with same locale" do
     R18n.extension_places << EXT
 
     i18n = R18n::I18n.new(['notransl', 'en'], DIR)
-    i18n.ext.should == 'Extension'
+    expect(i18n.ext).to eq('Extension')
   end
 
   it "ignores case on loading" do
     i18n = R18n::I18n.new('nolocale', [DIR])
-    i18n.one.should == 'ONE'
+    expect(i18n.one).to eq('ONE')
 
     i18n = R18n::I18n.new('nolocale', [DIR])
-    i18n.one.should == 'ONE'
+    expect(i18n.one).to eq('ONE')
   end
 
   it "loads default translation" do
     i18n = R18n::I18n.new('nolocale', DIR)
-    i18n.one.should == 'ONE'
-    i18n.two.should == 'Two'
+    expect(i18n.one).to eq('ONE')
+    expect(i18n.two).to eq('Two')
   end
 
   it "loads sublocales for first locale" do
     R18n::I18n.default = 'notransl'
 
     i18n = R18n::I18n.new('ru', DIR)
-    i18n.one.should == 'Один'
-    i18n.two.should == 'Two'
+    expect(i18n.one).to eq('Один')
+    expect(i18n.two).to eq('Two')
   end
 
   it "returns available translations" do
     i18n = R18n::I18n.new('en', DIR)
-    i18n.available_locales.should =~ [R18n.locale('nolocale'),
+    expect(i18n.available_locales).to match_array([R18n.locale('nolocale'),
                                       R18n.locale('ru'),
-                                      R18n.locale('en')]
+                                      R18n.locale('en')])
   end
 
   it "caches translations" do
     counter = CounterLoader.new('en')
 
     R18n::I18n.new('en', counter)
-    counter.loaded.should == 1
+    expect(counter.loaded).to eq(1)
 
     R18n::I18n.new('en', counter)
-    counter.loaded.should == 1
+    expect(counter.loaded).to eq(1)
 
     R18n.clear_cache!
     R18n::I18n.new('en', counter)
-    counter.loaded.should == 2
+    expect(counter.loaded).to eq(2)
   end
 
   it "doesn't clear cache when custom filters are specified" do
     counter = CounterLoader.new('en')
 
-    R18n::I18n.new('en', counter, :off_filters => :untranslated,
-      :on_filters => :untranslated_html)
-    counter.loaded.should == 1
+    R18n::I18n.new('en', counter,
+      off_filters: :untranslated, on_filters: :untranslated_html)
+    expect(counter.loaded).to eq(1)
 
-    R18n::I18n.new('en', counter, :off_filters => :untranslated,
-      :on_filters => :untranslated_html)
-    counter.loaded.should == 1
+    R18n::I18n.new('en', counter,
+      off_filters: :untranslated, on_filters: :untranslated_html)
+    expect(counter.loaded).to eq(1)
   end
 
   it "caches translations by used locales" do
     counter = CounterLoader.new('en', 'ru')
 
     R18n::I18n.new('en', counter)
-    counter.loaded.should == 1
+    expect(counter.loaded).to eq(1)
 
     R18n::I18n.new(['en', 'fr'], counter)
-    counter.loaded.should == 1
+    expect(counter.loaded).to eq(1)
 
     R18n::I18n.new(['en', 'ru'], counter)
-    counter.loaded.should == 3
+    expect(counter.loaded).to eq(3)
 
     R18n::I18n.new(['ru', 'en'], counter)
-    counter.loaded.should == 5
+    expect(counter.loaded).to eq(5)
   end
 
   it "caches translations by places" do
     counter = CounterLoader.new('en', 'ru')
 
     R18n::I18n.new('en', counter)
-    counter.loaded.should == 1
+    expect(counter.loaded).to eq(1)
 
     R18n::I18n.new('en', [counter, DIR])
-    counter.loaded.should == 2
+    expect(counter.loaded).to eq(2)
 
     R18n.extension_places << EXT
     R18n::I18n.new('en', counter)
-    counter.loaded.should == 3
+    expect(counter.loaded).to eq(3)
 
     same = CounterLoader.new('en', 'ru')
     R18n::I18n.new('en', same)
-    same.loaded.should == 0
+    expect(same.loaded).to eq(0)
 
     different = CounterLoader.new('en', 'fr')
     R18n::I18n.new('en', different)
-    different.loaded.should == 1
+    expect(different.loaded).to eq(1)
   end
 
   it "reloads translations" do
@@ -191,50 +190,49 @@ describe R18n::I18n do
     end
 
     i18n = R18n::I18n.new('en', loader.new)
-    i18n.one.should == 1
+    expect(i18n.one).to eq(1)
 
     i18n.reload!
-    i18n.one.should == 2
+    expect(i18n.one).to eq(2)
   end
 
   it "returns translations" do
     i18n = R18n::I18n.new('en', DIR)
-    i18n.t.should be_a(R18n::Translation)
-    i18n.t.one.should == 'One'
+    expect(i18n.t).to be_kind_of(R18n::Translation)
+    expect(i18n.t.one).to eq('One')
   end
 
   it "returns first locale with locale file" do
     i18n = R18n::I18n.new(['notransl', 'nolocale', 'ru', 'en'], DIR)
-    i18n.locale.should      == R18n.locale('nolocale')
-    i18n.locale.base.should == R18n.locale('ru')
+    expect(i18n.locale).to      eq(R18n.locale('nolocale'))
+    expect(i18n.locale.base).to eq(R18n.locale('ru'))
   end
 
   it "localizes objects" do
     i18n = R18n::I18n.new('ru')
 
-    i18n.l(-123456789).should == '−123 456 789'
-    i18n.l(-12345.67).should  == '−12 345,67'
+    expect(i18n.l(-123456789)).to eq('−123 456 789')
+    expect(i18n.l(-12345.67)).to  eq('−12 345,67')
 
     time = Time.at(0).utc
-    i18n.l(time, '%A').should      == 'Четверг'
-    i18n.l(time, :month).should    == 'Январь'
-    i18n.l(time, :standard).should == '01.01.1970 00:00'
-    i18n.l(time, :full).should     == ' 1 января 1970 00:00'
+    expect(i18n.l(time, '%A')).to      eq('Четверг')
+    expect(i18n.l(time, :month)).to    eq('Январь')
+    expect(i18n.l(time, :standard)).to eq('01.01.1970 00:00')
+    expect(i18n.l(time, :full)).to     eq(' 1 января 1970 00:00')
 
-    i18n.l(Date.new(0)).should == '01.01.0000'
+    expect(i18n.l(Date.new(0))).to eq('01.01.0000')
   end
 
-  it "returns marshalizable values", :not_ruby => 1.8 do
-    i18n    = R18n::I18n.new('en', DIR, :off_filters => :untranslated,
-                                        :on_filters  => :untranslated_html)
+  it "returns marshalizable values" do
+    i18n    = R18n::I18n.new('en', DIR, off_filters: :untranslated,
+                                        on_filters:  :untranslated_html)
     demarsh = Marshal.load(Marshal.dump(i18n.t.one))
 
-    i18n.t.one.should        == demarsh
-    i18n.t.one.path.should   == demarsh.path
-    i18n.t.one.locale.should == demarsh.locale
+    expect(i18n.t.one).to        eq(demarsh)
+    expect(i18n.t.one.path).to   eq(demarsh.path)
+    expect(i18n.t.one.locale).to eq(demarsh.locale)
 
     demarsh = Marshal.load(Marshal.dump(i18n.t.no_translation))
-    i18n.t.no_translation.should == demarsh
+    expect(i18n.t.no_translation).to eq(demarsh)
   end
-
 end

data/spec/locale_spec.rb

@@ -1,4 +1,3 @@
-# encoding: utf-8
 require File.expand_path('../spec_helper', __FILE__)
 require 'bigdecimal'
 
@@ -9,100 +8,100 @@ describe R18n::Locale do
   end
 
   it "returns all available locales" do
-    R18n::Locale.available.class.should == Array
-    R18n::Locale.available.should_not be_empty
+    expect(R18n::Locale.available.class).to eq(Array)
+    expect(R18n::Locale.available).not_to be_empty
   end
 
   it "checks is locale exists" do
-    R18n::Locale.exists?('ru').should be_true
-    R18n::Locale.exists?('nolocale').should be_false
+    expect(R18n::Locale.exists?('ru')).to be true
+    expect(R18n::Locale.exists?('nolocale')).to be false
   end
 
   it "sets locale properties" do
     locale_class = Class.new(R18n::Locale) do
-      set :one => 1
-      set :two => 2
+      set one: 1
+      set two: 2
     end
     locale = locale_class.new
-    locale.one.should == 1
-    locale.two.should == 2
+    expect(locale.one).to eq(1)
+    expect(locale.two).to eq(2)
   end
 
   it "loads locale" do
-    @ru.class.should == R18n::Locales::Ru
-    @ru.code.should  == 'ru'
-    @ru.title.should == 'Русский'
+    expect(@ru.class).to eq(R18n::Locales::Ru)
+    expect(@ru.code).to  eq('ru')
+    expect(@ru.title).to eq('Русский')
   end
 
   it "loads locale by Symbol" do
-    R18n.locale(:ru).should == R18n.locale('ru')
+    expect(R18n.locale(:ru)).to eq(R18n.locale('ru'))
   end
 
   it "equals to another locale with same code" do
-    @en.should_not == @ru
-    @en.should == R18n.locale('en')
+    expect(@en).not_to eq(@ru)
+    expect(@en).to eq(R18n.locale('en'))
   end
 
   it "prints human readable representation" do
-    @ru.inspect.should == 'Locale ru (Русский)'
+    expect(@ru.inspect).to eq('Locale ru (Русский)')
   end
 
   it "returns pluralization type by elements count" do
-    @en.pluralize(0).should == 0
-    @en.pluralize(1).should == 1
-    @en.pluralize(5).should == 'n'
+    expect(@en.pluralize(0)).to eq(0)
+    expect(@en.pluralize(1)).to eq(1)
+    expect(@en.pluralize(5)).to eq('n')
   end
 
   it "uses UnsupportedLocale if locale file isn't exists" do
-    @en.should be_supported
+    expect(@en).to be_supported
 
     unsupported = R18n.locale('nolocale-DL')
-    unsupported.should_not be_supported
-    unsupported.should be_a(R18n::UnsupportedLocale)
+    expect(unsupported).not_to be_supported
+    expect(unsupported).to be_kind_of(R18n::UnsupportedLocale)
 
-    unsupported.code.downcase.should  == 'nolocale-dl'
-    unsupported.title.downcase.should == 'nolocale-dl'
-    unsupported.ltr?.should be_true
+    expect(unsupported.code.downcase).to  eq('nolocale-dl')
+    expect(unsupported.title.downcase).to eq('nolocale-dl')
+    expect(unsupported.ltr?).to be true
 
-    unsupported.pluralize(5).should == 'n'
-    unsupported.inspect.downcase.should == 'unsupported locale nolocale-dl'
+    expect(unsupported.pluralize(5)).to eq('n')
+    expect(unsupported.inspect.downcase).to eq('unsupported locale nolocale-dl')
   end
 
   it "formats number in local traditions" do
-    @en.localize(-123456789).should == "−123,456,789"
+    expect(@en.localize(-123456789)).to eq("−123,456,789")
   end
 
   it "formats float in local traditions" do
-    @en.localize(-12345.67).should == "−12,345.67"
-    @en.localize(BigDecimal.new("-12345.67")).should == "−12,345.67"
+    expect(@en.localize(-12345.67)).to eq("−12,345.67")
+    expect(@en.localize(BigDecimal.new("-12345.67"))).to eq("−12,345.67")
   end
 
   it "translates month, week days and am/pm names in strftime" do
     i18n = R18n::I18n.new('ru')
     time = Time.at(0).utc
 
-    @ru.localize(time, '%a %A').should == 'Чтв Четверг'
-    @ru.localize(time, '%b %B').should == 'янв января'
-    @ru.localize(time, '%H:%M%p').should == '00:00 утра'
+    expect(@ru.localize(time, '%a %A')).to eq('Чтв Четверг')
+    expect(@ru.localize(time, '%b %B')).to eq('янв января')
+    expect(@ru.localize(time, '%H:%M%p')).to eq('00:00 утра')
   end
 
   it "generates locale code by locale class name" do
-    R18n.locale('ru').code.should    == 'ru'
-    R18n.locale('zh-CN').code.should == 'zh-CN'
+    expect(R18n.locale('ru').code).to    eq('ru')
+    expect(R18n.locale('zh-CN').code).to eq('zh-CN')
   end
 
   it "localizes date for human" do
     i18n = R18n::I18n.new('en')
 
-    @en.localize(Date.today + 2, :human, i18n).should == 'after 2 days'
-    @en.localize(Date.today + 1, :human, i18n).should == 'tomorrow'
-    @en.localize(Date.today,     :human, i18n).should == 'today'
-    @en.localize(Date.today - 1, :human, i18n).should == 'yesterday'
-    @en.localize(Date.today - 3, :human, i18n).should == '3 days ago'
+    expect(@en.localize(Date.today + 2, :human, i18n)).to eq('after 2 days')
+    expect(@en.localize(Date.today + 1, :human, i18n)).to eq('tomorrow')
+    expect(@en.localize(Date.today,     :human, i18n)).to eq('today')
+    expect(@en.localize(Date.today - 1, :human, i18n)).to eq('yesterday')
+    expect(@en.localize(Date.today - 3, :human, i18n)).to eq('3 days ago')
 
-    y2k = Date.parse('2000-01-08')
-    @en.localize(y2k, :human, i18n, y2k + 8  ).should == '8th of January'
-    @en.localize(y2k, :human, i18n, y2k - 365).should == '8th of January, 2000'
+    y2k = Date.parse('2000-05-08')
+    expect(@en.localize(y2k, :human, i18n, y2k + 8  )).to eq('8th of May')
+    expect(@en.localize(y2k, :human, i18n, y2k - 365)).to eq('8th of May, 2000')
   end
 
   it "localizes times for human" do
@@ -112,62 +111,63 @@ describe R18n::Locale do
     zero   = Time.at(0).utc
     p = [:human, R18n::I18n.new('en'), zero]
 
-    @en.localize( zero + 7  * day,    *p).should == '8th of January 00:00'
-    @en.localize( zero + 50 * hour,   *p).should == 'after 2 days 02:00'
-    @en.localize( zero + 25 * hour,   *p).should == 'tomorrow 01:00'
-    @en.localize( zero + 70 * minute, *p).should == 'after 1 hour'
-    @en.localize( zero + hour,        *p).should == 'after 1 hour'
-    @en.localize( zero + 38 * minute, *p).should == 'after 38 minutes'
-    @en.localize( zero + 5,           *p).should == 'now'
-    @en.localize( zero - 15,          *p).should == 'now'
-    @en.localize( zero - minute,      *p).should == '1 minute ago'
-    @en.localize( zero - hour + 59,   *p).should == '59 minutes ago'
-    @en.localize( zero - 2  * hour,   *p).should == '2 hours ago'
-    @en.localize( zero - 13 * hour,   *p).should == 'yesterday 11:00'
-    @en.localize( zero - 50 * hour,   *p).should == '3 days ago 22:00'
-
-    @en.localize( zero - 9  * day,  *p).should == '23rd of December, 1969 00:00'
-    @en.localize( zero - 365 * day, *p).should == '1st of January, 1969 00:00'
+    expect(@en.localize( zero + 7  * day,    *p)).to eq('8th of January 00:00')
+    expect(@en.localize( zero + 50 * hour,   *p)).to eq('after 2 days 02:00')
+    expect(@en.localize( zero + 25 * hour,   *p)).to eq('tomorrow 01:00')
+    expect(@en.localize( zero + 70 * minute, *p)).to eq('after 1 hour')
+    expect(@en.localize( zero + hour,        *p)).to eq('after 1 hour')
+    expect(@en.localize( zero + 38 * minute, *p)).to eq('after 38 minutes')
+    expect(@en.localize( zero + 5,           *p)).to eq('now')
+    expect(@en.localize( zero - 15,          *p)).to eq('now')
+    expect(@en.localize( zero - minute,      *p)).to eq('1 minute ago')
+    expect(@en.localize( zero - hour + 59,   *p)).to eq('59 minutes ago')
+    expect(@en.localize( zero - 2  * hour,   *p)).to eq('2 hours ago')
+    expect(@en.localize( zero - 13 * hour,   *p)).to eq('yesterday 11:00')
+    expect(@en.localize( zero - 50 * hour,   *p)).to eq('3 days ago 22:00')
+
+    expect(@en.localize( zero - 9  * day,  *p)).to eq(
+      '23rd of December, 1969 00:00')
+    expect(@en.localize( zero - 365 * day, *p)).to eq(
+      '1st of January, 1969 00:00')
   end
 
   it "uses standard formatter by default" do
-    @ru.localize(Time.at(0).utc).should == '01.01.1970 00:00'
+    expect(@ru.localize(Time.at(0).utc)).to eq('01.01.1970 00:00')
   end
 
   it "doesn't localize time without i18n object" do
-    @ru.localize(Time.at(0)).should_not == Time.at(0).to_s
-    @ru.localize(Time.at(0), :full).should_not == Time.at(0).to_s
+    expect(@ru.localize(Time.at(0))).not_to eq(Time.at(0).to_s)
+    expect(@ru.localize(Time.at(0), :full)).not_to eq(Time.at(0).to_s)
 
-    @ru.localize(Time.at(0), :human).should == Time.at(0).to_s
+    expect(@ru.localize(Time.at(0), :human)).to eq(Time.at(0).to_s)
   end
 
   it "raises error on unknown formatter" do
-    lambda {
+    expect {
       @ru.localize(Time.at(0).utc, R18n::I18n.new('ru'), :unknown)
-    }.should raise_error(ArgumentError, /formatter/)
+    }.to raise_error(ArgumentError, /formatter/)
   end
 
   it "deletes slashed from locale for security reasons" do
     locale = R18n.locale('../spec/translations/general/en')
-    locale.should be_a(R18n::UnsupportedLocale)
+    expect(locale).to be_kind_of(R18n::UnsupportedLocale)
   end
 
   it "ignores code case in locales" do
     upcase   = R18n.locale('RU')
     downcase = R18n.locale('ru')
-    upcase.should == downcase
-    upcase.code.should   == 'ru'
-    downcase.code.should == 'ru'
+    expect(upcase).to eq(downcase)
+    expect(upcase.code).to   eq('ru')
+    expect(downcase.code).to eq('ru')
 
     upcase   = R18n.locale('nolocale')
     downcase = R18n.locale('nolocale')
-    upcase.should == downcase
-    upcase.code.should   == 'nolocale'
-    downcase.code.should == 'nolocale'
+    expect(upcase).to eq(downcase)
+    expect(upcase.code).to   eq('nolocale')
+    expect(downcase.code).to eq('nolocale')
   end
 
   it "loads locale with underscore" do
-    R18n.locale('nolocale-DL').code.should == 'nolocale-dl'
+    expect(R18n.locale('nolocale-DL').code).to eq('nolocale-dl')
   end
-
 end

data/spec/locales/cs_spec.rb

@@ -3,21 +3,21 @@ require File.expand_path('../../spec_helper', __FILE__)
 describe R18n::Locales::Cs do
   it "uses Czech pluralization" do
     cs = R18n.locale('cs')
-    cs.pluralize(0).should == 0
-    cs.pluralize(1).should == 1
+    expect(cs.pluralize(0)).to eq(0)
+    expect(cs.pluralize(1)).to eq(1)
 
-    cs.pluralize(2).should == 2
-    cs.pluralize(3).should == 2
-    cs.pluralize(4).should == 2
+    expect(cs.pluralize(2)).to eq(2)
+    expect(cs.pluralize(3)).to eq(2)
+    expect(cs.pluralize(4)).to eq(2)
 
-    cs.pluralize(5).should   == 'n'
-    cs.pluralize(21).should  == 'n'
-    cs.pluralize(11).should  == 'n'
-    cs.pluralize(12).should  == 'n'
-    cs.pluralize(22).should  == 'n'
-    cs.pluralize(57).should  == 'n'
-    cs.pluralize(101).should == 'n'
-    cs.pluralize(102).should == 'n'
-    cs.pluralize(111).should == 'n'
+    expect(cs.pluralize(5)).to   eq('n')
+    expect(cs.pluralize(21)).to  eq('n')
+    expect(cs.pluralize(11)).to  eq('n')
+    expect(cs.pluralize(12)).to  eq('n')
+    expect(cs.pluralize(22)).to  eq('n')
+    expect(cs.pluralize(57)).to  eq('n')
+    expect(cs.pluralize(101)).to eq('n')
+    expect(cs.pluralize(102)).to eq('n')
+    expect(cs.pluralize(111)).to eq('n')
   end
 end

data/spec/locales/en-us_spec.rb

@@ -3,11 +3,11 @@ require File.expand_path('../../spec_helper', __FILE__)
 describe R18n::Locales::EnUs do
   it "formats American English date" do
     enUS = R18n::I18n.new('en-US')
-    enUS.l(Date.parse('2009-05-01'), :full).should ==  'May 1st, 2009'
-    enUS.l(Date.parse('2009-05-02'), :full).should ==  'May 2nd, 2009'
-    enUS.l(Date.parse('2009-05-03'), :full).should ==  'May 3rd, 2009'
-    enUS.l(Date.parse('2009-05-04'), :full).should ==  'May 4th, 2009'
-    enUS.l(Date.parse('2009-05-11'), :full).should == 'May 11th, 2009'
-    enUS.l(Date.parse('2009-05-21'), :full).should == 'May 21st, 2009'
+    expect(enUS.l(Date.parse('2009-05-01'), :full)).to eq('May 1st, 2009')
+    expect(enUS.l(Date.parse('2009-05-02'), :full)).to eq('May 2nd, 2009')
+    expect(enUS.l(Date.parse('2009-05-03'), :full)).to eq('May 3rd, 2009')
+    expect(enUS.l(Date.parse('2009-05-04'), :full)).to eq('May 4th, 2009')
+    expect(enUS.l(Date.parse('2009-05-11'), :full)).to eq('May 11th, 2009')
+    expect(enUS.l(Date.parse('2009-05-21'), :full)).to eq('May 21st, 2009')
   end
 end

data/spec/locales/en_spec.rb

@@ -3,11 +3,11 @@ require File.expand_path('../../spec_helper', __FILE__)
 describe R18n::Locales::En do
   it "formats English date" do
     en = R18n::I18n.new('en')
-    en.l(Date.parse('2009-05-01'), :full).should ==  '1st of May, 2009'
-    en.l(Date.parse('2009-05-02'), :full).should ==  '2nd of May, 2009'
-    en.l(Date.parse('2009-05-03'), :full).should ==  '3rd of May, 2009'
-    en.l(Date.parse('2009-05-04'), :full).should ==  '4th of May, 2009'
-    en.l(Date.parse('2009-05-11'), :full).should == '11th of May, 2009'
-    en.l(Date.parse('2009-05-21'), :full).should == '21st of May, 2009'
+    expect(en.l(Date.parse('2009-05-01'), :full)).to eq('1st of May, 2009')
+    expect(en.l(Date.parse('2009-05-02'), :full)).to eq('2nd of May, 2009')
+    expect(en.l(Date.parse('2009-05-03'), :full)).to eq('3rd of May, 2009')
+    expect(en.l(Date.parse('2009-05-04'), :full)).to eq('4th of May, 2009')
+    expect(en.l(Date.parse('2009-05-11'), :full)).to eq('11th of May, 2009')
+    expect(en.l(Date.parse('2009-05-21'), :full)).to eq('21st of May, 2009')
   end
 end

data/spec/locales/fr_spec.rb

@@ -3,7 +3,7 @@ require File.expand_path('../../spec_helper', __FILE__)
 describe R18n::Locales::Fr do
   it "formats French date" do
     fr = R18n::I18n.new('fr')
-    fr.l(Date.parse('2009-07-01'), :full).should ==  '1er juillet 2009'
-    fr.l(Date.parse('2009-07-02'), :full).should ==  ' 2 juillet 2009'
+    expect(fr.l(Date.parse('2009-07-01'), :full)).to eq('1er juillet 2009')
+    expect(fr.l(Date.parse('2009-07-02'), :full)).to eq(' 2 juillet 2009')
   end
 end