Remove specs deprecations.

spec/i18n/locale/datetime_spec.rb

@@ -12,91 +12,91 @@
 
   describe "with date formats" do
     it "should use default format" do
-      l(@date).should == "01.12.1985"
+      expect(l(@date)).to eq "01.12.1985"
     end
 
     it "should use short format" do
-      l(@date, :format => :short).should == "01 дек."
+      expect(l(@date, :format => :short)).to eq "01 дек."
     end
 
     it "should use long format" do
-      l(@date, :format => :long).should == "01 декабря 1985"
+      expect(l(@date, :format => :long)).to eq "01 декабря 1985"
     end
   end
 
   describe "with date day names" do
     it "should use day names" do
-      l(@date, :format => "%d %B (%A)").should == "01 декабря (воскресенье)"
-      l(@date, :format => "%d %B %Y года было %A").should == "01 декабря 1985 года было воскресенье"
+      expect(l(@date, :format => "%d %B (%A)")).to eq "01 декабря (воскресенье)"
+      expect(l(@date, :format => "%d %B %Y года было %A")).to eq "01 декабря 1985 года было воскресенье"
     end
 
     it "should use standalone day names" do
-      l(@date, :format => "%A").should == "Воскресенье"
-      l(@date, :format => "%A, %d %B").should == "Воскресенье, 01 декабря"
+      expect(l(@date, :format => "%A")).to eq "Воскресенье"
+      expect(l(@date, :format => "%A, %d %B")).to eq "Воскресенье, 01 декабря"
     end
 
     it "should use abbreviated day names" do
-      l(@date, :format => "%a").should == "Вс"
-      l(@date, :format => "%a, %d %b %Y").should == "Вс, 01 дек. 1985"
+      expect(l(@date, :format => "%a")).to eq "Вс"
+      expect(l(@date, :format => "%a, %d %b %Y")).to eq "Вс, 01 дек. 1985"
     end
   end
 
   describe "with month names" do
     it "should use month names" do
-      l(@date, :format => "%d %B").should == "01 декабря"
-      l(@date, :format => "%-d %B").should == "1 декабря"
+      expect(l(@date, :format => "%d %B")).to eq "01 декабря"
+      expect(l(@date, :format => "%-d %B")).to eq "1 декабря"
 
       if RUBY_VERSION > "1.9.2"
-        l(@date, :format => "%1d %B").should == "1 декабря"
-        l(@date, :format => "%2d %B").should == "01 декабря"
+        expect(l(@date, :format => "%1d %B")).to eq "1 декабря"
+        expect(l(@date, :format => "%2d %B")).to eq "01 декабря"
       end
 
-      l(@date, :format => "%e %B %Y").should == " 1 декабря 1985"
-      l(@date, :format => "<b>%d</b> %B").should == "<b>01</b> декабря"
-      l(@date, :format => "<strong>%e</strong> %B %Y").should == "<strong> 1</strong> декабря 1985"
-      l(@date, :format => "А было тогда %eе число %B %Y").should == "А было тогда  1е число декабря 1985"
+      expect(l(@date, :format => "%e %B %Y")).to eq " 1 декабря 1985"
+      expect(l(@date, :format => "<b>%d</b> %B")).to eq "<b>01</b> декабря"
+      expect(l(@date, :format => "<strong>%e</strong> %B %Y")).to eq "<strong> 1</strong> декабря 1985"
+      expect(l(@date, :format => "А было тогда %eе число %B %Y")).to eq "А было тогда  1е число декабря 1985"
     end
 
     it "should use standalone month names" do
-      l(@date, :format => "%B").should == "Декабрь"
-      l(@date, :format => "%B %Y").should == "Декабрь 1985"
+      expect(l(@date, :format => "%B")).to eq "Декабрь"
+      expect(l(@date, :format => "%B %Y")).to eq "Декабрь 1985"
     end
 
     it "should use abbreviated month names" do
       @date = Date.parse("1985-03-01")
-      l(@date, :format => "%d %b").should == "01 марта"
-      l(@date, :format => "%e %b %Y").should == " 1 марта 1985"
-      l(@date, :format => "<b>%d</b> %b").should == "<b>01</b> марта"
-      l(@date, :format => "<strong>%e</strong> %b %Y").should == "<strong> 1</strong> марта 1985"
+      expect(l(@date, :format => "%d %b")).to eq "01 марта"
+      expect(l(@date, :format => "%e %b %Y")).to eq " 1 марта 1985"
+      expect(l(@date, :format => "<b>%d</b> %b")).to eq "<b>01</b> марта"
+      expect(l(@date, :format => "<strong>%e</strong> %b %Y")).to eq "<strong> 1</strong> марта 1985"
     end
 
     it "should use standalone abbreviated month names" do
       @date = Date.parse("1985-03-01")
-      l(@date, :format => "%b").should == "март"
-      l(@date, :format => "%b %Y").should == "март 1985"
+      expect(l(@date, :format => "%b")).to eq "март"
+      expect(l(@date, :format => "%b %Y")).to eq "март 1985"
     end
   end
 
   it "should define default date components order: day, month, year" do
-    I18n.backend.translate(Russian.locale, :"date.order").should == [:day, :month, :year]
+    expect(I18n.backend.translate(Russian.locale, :"date.order")).to eq [:day, :month, :year]
   end
 
   describe "with time formats" do
     it "should use default format" do
-      l(@time).should =~ /^Вс, 01 дек. 1985, 16:05:00/
+      expect(l(@time)).to match /^Вс, 01 дек. 1985, 16:05:00/
     end
 
     it "should use short format" do
-      l(@time, :format => :short).should == "01 дек., 16:05"
+      expect(l(@time, :format => :short)).to eq "01 дек., 16:05"
     end
 
     it "should use long format" do
-      l(@time, :format => :long).should == "01 декабря 1985, 16:05"
+      expect(l(@time, :format => :long)).to eq "01 декабря 1985, 16:05"
     end
 
     it "should define am and pm" do
-      I18n.backend.translate(Russian.locale, :"time.am").should_not be_nil
-      I18n.backend.translate(Russian.locale, :"time.pm").should_not be_nil
+      expect(I18n.backend.translate(Russian.locale, :"time.am")).to_not be_nil
+      expect(I18n.backend.translate(Russian.locale, :"time.pm")).to_not be_nil
     end
   end
 

spec/i18n/locale/pluralization_spec.rb

@@ -12,17 +12,17 @@
   end
 
   it "should pluralize correctly" do
-    @backend.send(:pluralize, :'ru', @hash, 1).should == 'one'
-    @backend.send(:pluralize, :'ru', @hash, 2).should == 'few'
-    @backend.send(:pluralize, :'ru', @hash, 3).should == 'few'
-    @backend.send(:pluralize, :'ru', @hash, 5).should == 'many'
-    @backend.send(:pluralize, :'ru', @hash, 10).should == 'many'
-    @backend.send(:pluralize, :'ru', @hash, 11).should == 'many'
-    @backend.send(:pluralize, :'ru', @hash, 21).should == 'one'
-    @backend.send(:pluralize, :'ru', @hash, 29).should == 'many'
-    @backend.send(:pluralize, :'ru', @hash, 131).should == 'one'
-    @backend.send(:pluralize, :'ru', @hash, 1.31).should == 'other'
-    @backend.send(:pluralize, :'ru', @hash, 2.31).should == 'other'
-    @backend.send(:pluralize, :'ru', @hash, 3.31).should == 'other'
+    expect(@backend.send(:pluralize, :'ru', @hash, 1)).to eq 'one'
+    expect(@backend.send(:pluralize, :'ru', @hash, 2)).to eq 'few'
+    expect(@backend.send(:pluralize, :'ru', @hash, 3)).to eq 'few'
+    expect(@backend.send(:pluralize, :'ru', @hash, 5)).to eq 'many'
+    expect(@backend.send(:pluralize, :'ru', @hash, 10)).to eq 'many'
+    expect(@backend.send(:pluralize, :'ru', @hash, 11)).to eq 'many'
+    expect(@backend.send(:pluralize, :'ru', @hash, 21)).to eq 'one'
+    expect(@backend.send(:pluralize, :'ru', @hash, 29)).to eq 'many'
+    expect(@backend.send(:pluralize, :'ru', @hash, 131)).to eq 'one'
+    expect(@backend.send(:pluralize, :'ru', @hash, 1.31)).to eq 'other'
+    expect(@backend.send(:pluralize, :'ru', @hash, 2.31)).to eq 'other'
+    expect(@backend.send(:pluralize, :'ru', @hash, 3.31)).to eq 'other'
   end
 end

spec/locale_spec.rb

@@ -27,18 +27,18 @@
     time.pm
   ).each do |key| 
     it "should define '#{key}' in datetime translations" do
-      lookup(key).should_not be_nil
+      expect(lookup(key)).to_not be_nil
     end
   end
 
   it "should load pluralization rules" do
-    lookup(:'i18n.plural.rule').should_not be_nil
-    lookup(:'i18n.plural.rule').is_a?(Proc).should be true
+    expect(lookup(:'i18n.plural.rule')).to_not be_nil
+    expect(lookup(:'i18n.plural.rule').is_a?(Proc)).to be true
   end
 
   it "should load transliteration rule" do
-    lookup(:'i18n.transliterate.rule').should_not be_nil
-    lookup(:'i18n.transliterate.rule').is_a?(Proc).should be true
+    expect(lookup(:'i18n.transliterate.rule')).to_not be_nil
+    expect(lookup(:'i18n.transliterate.rule').is_a?(Proc)).to be true
   end
 
   def lookup(*args)

spec/russian_spec.rb

@@ -5,11 +5,11 @@
 describe Russian do
   describe "with locale" do
     it "should define :'ru' LOCALE" do
-      Russian::LOCALE.should == :'ru'
+      expect(Russian::LOCALE).to eq :'ru'
     end
 
     it "should provide 'locale' proxy" do
-      Russian.locale.should == Russian::LOCALE
+      expect(Russian.locale).to eq Russian::LOCALE
     end
   end
 
@@ -22,19 +22,19 @@
     it "should keep existing translations while switching backends" do
       I18n.load_path << File.join(File.dirname(__FILE__), 'fixtures', 'en.yml')
       Russian.init_i18n
-      I18n.t(:foo, :locale => :'en').should == "bar"
+      expect(I18n.t(:foo, :locale => :'en')).to eq "bar"
     end
 
     it "should keep existing :ru translations while switching backends" do
       I18n.load_path << File.join(File.dirname(__FILE__), 'fixtures', 'ru.yml')
       Russian.init_i18n
-      I18n.t(:'date.formats.default', :locale => :'ru').should == "override"
+      expect(I18n.t(:'date.formats.default', :locale => :'ru')).to eq "override"
     end
 
     it "should NOT set default locale to Russian locale" do
       locale = I18n.default_locale
       Russian.init_i18n
-      I18n.default_locale.should == locale
+      expect(I18n.default_locale).to eq locale
     end
   end
 
@@ -46,7 +46,7 @@
 
     %w(l localize).each do |method|
       it "'#{method}' should call I18n backend localize" do
-        I18n.should_receive(:localize).with(@time, @options.merge({ :locale => Russian.locale }))
+        expect(I18n).to receive(:localize).with(@time, @options.merge({ :locale => Russian.locale }))
         Russian.send(method, @time, @options)
       end
     end
@@ -60,7 +60,7 @@
 
     %w(t translate).each do |method|
       it "'#{method}' should call I18n backend translate" do
-        I18n.should_receive(:translate).with(@object, @options.merge({ :locale => Russian.locale }))
+        expect(I18n).to receive(:translate).with(@object, @options.merge({ :locale => Russian.locale }))
         Russian.send(method, @object, @options)
       end
     end
@@ -73,12 +73,12 @@
 
     it "should call localize with object and format" do
       format = "%d %B %Y"
-      Russian.should_receive(:localize).with(@time, { :format => format })
+      expect(Russian).to receive(:localize).with(@time, { :format => format })
       Russian.strftime(@time, format)
     end
 
     it "should call localize with object and default format when format is not specified" do
-      Russian.should_receive(:localize).with(@time, { :format => :default })
+      expect(Russian).to receive(:localize).with(@time, { :format => :default })
       Russian.strftime(@time)
     end
   end
@@ -88,30 +88,30 @@
       it "'#{method}' should pluralize with variants given" do
         variants = %w(вещь вещи вещей вещи)
 
-        Russian.send(method, 1, *variants).should == "вещь"
-        Russian.send(method, 2, *variants).should == 'вещи'
-        Russian.send(method, 3, *variants).should == 'вещи'
-        Russian.send(method, 5, *variants).should == 'вещей'
-        Russian.send(method, 10, *variants).should == 'вещей'
-        Russian.send(method, 21, *variants).should == 'вещь'
-        Russian.send(method, 29, *variants).should == 'вещей'
-        Russian.send(method, 129, *variants).should == 'вещей'
-        Russian.send(method, 131, *variants).should == 'вещь'
-        Russian.send(method, 3.14, *variants).should == 'вещи'
+        expect(Russian.send(method, 1, *variants)).to eq "вещь"
+        expect(Russian.send(method, 2, *variants)).to eq 'вещи'
+        expect(Russian.send(method, 3, *variants)).to eq 'вещи'
+        expect(Russian.send(method, 5, *variants)).to eq 'вещей'
+        expect(Russian.send(method, 10, *variants)).to eq 'вещей'
+        expect(Russian.send(method, 21, *variants)).to eq 'вещь'
+        expect(Russian.send(method, 29, *variants)).to eq 'вещей'
+        expect(Russian.send(method, 129, *variants)).to eq 'вещей'
+        expect(Russian.send(method, 131, *variants)).to eq 'вещь'
+        expect(Russian.send(method, 3.14, *variants)).to eq 'вещи'
       end
 
       it "should raise an exception when first parameter is not a number" do
-        lambda { Russian.send(method, nil, "вещь", "вещи", "вещей") }.should raise_error(ArgumentError)
-        lambda { Russian.send(method, "вещь", "вещь", "вещи", "вещей") }.should raise_error(ArgumentError)
+        expect { Russian.send(method, nil, "вещь", "вещи", "вещей") }.to raise_error(ArgumentError)
+        expect { Russian.send(method, "вещь", "вещь", "вещи", "вещей") }.to raise_error(ArgumentError)
       end
 
       it "should raise an exception when there are not enough variants" do
-        lambda { Russian.send(method, 1) }.should raise_error(ArgumentError)
-        lambda { Russian.send(method, 1, "вещь") }.should raise_error(ArgumentError)
-        lambda { Russian.send(method, 1, "вещь", "вещи") }.should raise_error(ArgumentError)
-        lambda { Russian.send(method, 1, "вещь", "вещи", "вещей") }.should_not raise_error(ArgumentError)
-        lambda { Russian.send(method, 3.14, "вещь", "вещи", "вещей") }.should raise_error(ArgumentError)
-        lambda { Russian.send(method, 3.14, "вещь", "вещи", "вещей", "вещи") }.should_not raise_error(ArgumentError)
+        expect { Russian.send(method, 1) }.to raise_error(ArgumentError)
+        expect { Russian.send(method, 1, "вещь") }.to raise_error(ArgumentError)
+        expect { Russian.send(method, 1, "вещь", "вещи") }.to raise_error(ArgumentError)
+        expect { Russian.send(method, 1, "вещь", "вещи", "вещей") }.to_not raise_error
+        expect { Russian.send(method, 3.14, "вещь", "вещи", "вещей") }.to raise_error(ArgumentError)
+        expect { Russian.send(method, 3.14, "вещь", "вещи", "вещей", "вещи") }.to_not raise_error
       end
     end
   end

spec/transliteration_spec.rb

@@ -11,41 +11,41 @@ def t(str)
     %w(transliterate translit).each do |method|
       it "'#{method}' method should perform transliteration" do
         str = double(:str)
-        Russian::Transliteration.should_receive(:transliterate).with(str)
+        expect(Russian::Transliteration).to receive(:transliterate).with(str)
         Russian.send(method, str)
       end
     end
 
     # These tests are from rutils, <http://rutils.rubyforge.org>.
 
     it "should transliterate properly" do
-      t("Это просто некий текст").should == "Eto prosto nekiy tekst"
-      t("щ").should == "sch"
-      t("стансы").should == "stansy"
-      t("упущение").should == "upuschenie"
-      t("ш").should == "sh"
-      t("Ш").should == "SH"
-      t("ц").should == "ts"
+      expect(t("Это просто некий текст")).to eq "Eto prosto nekiy tekst"
+      expect(t("щ")).to eq "sch"
+      expect(t("стансы")).to eq "stansy"
+      expect(t("упущение")).to eq "upuschenie"
+      expect(t("ш")).to eq "sh"
+      expect(t("Ш")).to eq "SH"
+      expect(t("ц")).to eq "ts"
     end
 
     it "should properly transliterate mixed russian-english strings" do
-      t("Это кусок строки русских букв v peremeshku s latinizey i амперсандом (pozor!) & something").should == 
-        "Eto kusok stroki russkih bukv v peremeshku s latinizey i ampersandom (pozor!) & something"      
+      expect(t("Это кусок строки русских букв v peremeshku s latinizey i амперсандом (pozor!) & something"))
+        .to eq "Eto kusok stroki russkih bukv v peremeshku s latinizey i ampersandom (pozor!) & something"
     end
 
     it "should properly transliterate mixed case chars in a string" do
-      t("НЕВЕРОЯТНОЕ УПУЩЕНИЕ").should == "NEVEROYATNOE UPUSCHENIE"
-      t("Невероятное Упущение").should == "Neveroyatnoe Upuschenie"
-      t("Шерстяной Заяц").should == "Sherstyanoy Zayats"
-      t("Н.П. Шерстяков").should == "N.P. Sherstyakov"
-      t("ШАРОВАРЫ").should == "SHAROVARY"
+      expect(t("НЕВЕРОЯТНОЕ УПУЩЕНИЕ")).to eq "NEVEROYATNOE UPUSCHENIE"
+      expect(t("Невероятное Упущение")).to eq "Neveroyatnoe Upuschenie"
+      expect(t("Шерстяной Заяц")).to eq "Sherstyanoy Zayats"
+      expect(t("Н.П. Шерстяков")).to eq "N.P. Sherstyakov"
+      expect(t("ШАРОВАРЫ")).to eq "SHAROVARY"
     end
 
     it "should work for multi-char substrings" do
-      t("38 воробьёв").should == "38 vorobiev"
-      t("Вася Воробьёв").should == "Vasya Vorobiev"
-      t("Алябьев").should == "Alyabiev"
-      t("АЛЯБЬЕВ").should == "ALYABIEV"
+      expect(t("38 воробьёв")).to eq "38 vorobiev"
+      expect(t("Вася Воробьёв")).to eq "Vasya Vorobiev"
+      expect(t("Алябьев")).to eq "Alyabiev"
+      expect(t("АЛЯБЬЕВ")).to eq "ALYABIEV"
     end
   end
-end
+end