r18n-core 1.1.11 → 2.0.0

data/spec/locales/hu_spec.rb

@@ -1,18 +1,17 @@
-# encoding: utf-8
 require File.expand_path('../../spec_helper', __FILE__)
 
 describe R18n::Locales::Hu do
   it "uses Hungarian digits groups" do
     hu = R18n::I18n.new('hu')
-    hu.l(1000).should   ==  '1000'
-    hu.l(10000).should  ==  '10 000'
-    hu.l(-10000).should == '−10 000'
-    hu.l(100000).should ==  '100 000'
+    expect(hu.l(1000)).to   eq('1000')
+    expect(hu.l(10000)).to  eq('10 000')
+    expect(hu.l(-10000)).to eq('−10 000')
+    expect(hu.l(100000)).to eq('100 000')
   end
 
   it "uses Hungarian time format" do
     hu = R18n::I18n.new('hu')
-    hu.l(Time.at(0).utc).should        == '1970. 01. 01., 00:00'
-    hu.l(Time.at(0).utc, :full).should == '1970. január  1., 00:00'
+    expect(hu.l(Time.at(0).utc)).to        eq('1970. 01. 01., 00:00')
+    expect(hu.l(Time.at(0).utc, :full)).to eq('1970. január  1., 00:00')
   end
 end

data/spec/locales/it_spec.rb

@@ -1,11 +1,10 @@
-# encoding: utf-8
 require File.expand_path('../../spec_helper', __FILE__)
 
 describe R18n::Locales::It do
   it "formats Italian date" do
     italian = R18n::I18n.new('it')
-    italian.l(Date.parse('2009-07-01'), :full).should == "1º luglio 2009"
-    italian.l(Date.parse('2009-07-02'), :full).should == ' 2 luglio 2009'
-    italian.l(Date.parse('2009-07-12'), :full).should == '12 luglio 2009'
+    expect(italian.l(Date.parse('2009-07-01'), :full)).to eq("1º luglio 2009")
+    expect(italian.l(Date.parse('2009-07-02'), :full)).to eq(' 2 luglio 2009')
+    expect(italian.l(Date.parse('2009-07-12'), :full)).to eq('12 luglio 2009')
   end
 end

data/spec/locales/pl_spec.rb

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

data/spec/locales/ru_spec.rb

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

data/spec/locales/sk_spec.rb

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

data/spec/locales/th_spec.rb

@@ -3,7 +3,7 @@ require File.expand_path('../../spec_helper', __FILE__)
 describe R18n::Locales::Ru do
   it "uses Thai calendar" do
     th = R18n::I18n.new('th')
-    th.l(Time.at(0).utc, '%Y %y').should ==  '2513 13'
-    th.l(Time.at(0).utc).should == '01/01/2513 00:00'
+    expect(th.l(Time.at(0).utc, '%Y %y')).to eq('2513 13')
+    expect(th.l(Time.at(0).utc)).to eq('01/01/2513 00:00')
   end
 end

data/spec/r18n_spec.rb

@@ -1,4 +1,3 @@
-# encoding: utf-8
 require File.expand_path('../spec_helper', __FILE__)
 
 describe R18n do
@@ -13,10 +12,10 @@ describe R18n do
   it "stores I18n" do
     i18n = R18n::I18n.new('en')
     R18n.set(i18n)
-    R18n.get.should == i18n
+    expect(R18n.get).to eq(i18n)
 
     R18n.reset!
-    R18n.get.should be_nil
+    expect(R18n.get).to be_nil
   end
 
   it "sets setter to I18n" do
@@ -26,25 +25,25 @@ describe R18n do
     i18n = R18n::I18n.new('ru')
     R18n.set { i18n }
 
-    R18n.get.should == i18n
+    expect(R18n.get).to eq(i18n)
   end
 
   it "creates I18n object by shortcut" do
     R18n.set('en', DIR)
-    R18n.get.should be_a(R18n::I18n)
-    R18n.get.locales.should == [R18n.locale('en')]
-    R18n.get.translation_places.should == [R18n::Loader::YAML.new(DIR)]
+    expect(R18n.get).to be_kind_of(R18n::I18n)
+    expect(R18n.get.locales).to eq([R18n.locale('en')])
+    expect(R18n.get.translation_places).to eq([R18n::Loader::YAML.new(DIR)])
   end
 
   it "allows to return I18n arguments in setter block" do
     R18n.set { 'en' }
-    R18n.get.locales.should == [R18n.locale('en')]
+    expect(R18n.get.locales).to eq([R18n.locale('en')])
   end
 
   it "clears cache" do
     R18n.cache[:a] = 1
     R18n.clear_cache!
-    R18n.cache.should be_empty
+    expect(R18n.cache).to be_empty
   end
 
   it "resets I18n objects and cache" do
@@ -53,116 +52,115 @@ describe R18n do
     R18n.thread_set('en')
 
     R18n.reset!
-    R18n.get.should be_nil
-    R18n.cache.should be_empty
+    expect(R18n.get).to be_nil
+    expect(R18n.cache).to be_empty
   end
 
   it "stores I18n via thread_set" do
     i18n = R18n::I18n.new('en')
     R18n.thread_set(i18n)
-    R18n.get.should == i18n
+    expect(R18n.get).to eq(i18n)
 
     i18n = R18n::I18n.new('ru')
     R18n.thread_set { i18n }
-    R18n.get.should == i18n
+    expect(R18n.get).to eq(i18n)
   end
 
   it "allows to temporary change locale" do
     R18n.default_places = DIR
-    R18n.change('en').locales.should == [R18n.locale('en')]
-    R18n.change('en').should have(1).translation_places
-    R18n.change('en').translation_places.first.dir.should == DIR.to_s
+    expect(R18n.change('en').locales).to eq([R18n.locale('en')])
+    expect(R18n.change('en').translation_places.size).to eq(1)
+    expect(R18n.change('en').translation_places.first.dir).to eq(DIR.to_s)
   end
 
   it "allows to temporary change current locales" do
     R18n.set('ru')
-    R18n.change('en').locales.should == [R18n.locale('en'), R18n.locale('ru')]
-    R18n.change('en').translation_places.should == R18n.get.translation_places
-    R18n.get.locale.code.should.should == 'ru'
+    expect(R18n.change('en').locales).to eq(
+      [R18n.locale('en'), R18n.locale('ru')])
+    expect(R18n.change('en').translation_places).to eq(
+      R18n.get.translation_places)
+    expect(R18n.get.locale.code).to eq('ru')
   end
 
   it "allows to get Locale to temporary change" do
     R18n.set('ru')
-    R18n.change(R18n.locale('en')).locale.code.should == 'en'
+    expect(R18n.change(R18n.locale('en')).locale.code).to eq('en')
   end
 
   it "has shortcut to load locale" do
-    R18n.locale('ru').should == R18n::Locale.load('ru')
+    expect(R18n.locale('ru')).to eq(R18n::Locale.load('ru'))
   end
 
   it "stores default loader class" do
-    R18n.default_loader.should == R18n::Loader::YAML
+    expect(R18n.default_loader).to eq(R18n::Loader::YAML)
     R18n.default_loader = Class
-    R18n.default_loader.should == Class
+    expect(R18n.default_loader).to be_kind_of(Class)
   end
 
   it "stores cache" do
-    R18n.cache.should be_a(Hash)
+    expect(R18n.cache).to be_kind_of(Hash)
 
     R18n.cache = { 1 => 2 }
-    R18n.cache.should == { 1 => 2 }
+    expect(R18n.cache).to eq({ 1 => 2 })
 
     R18n.clear_cache!
-    R18n.cache.should == { }
-  end
-
-  it "converts Time to Date" do
-    R18n::Utils.to_date(Time.now).should == Date.today
+    expect(R18n.cache).to eq({ })
   end
 
   it "maps hash" do
-    R18n::Utils.hash_map({'a' => 1, 'b' => 2}) { |k, v| [k + 'a', v + 1] }.
-      should == { 'aa' => 2, 'ba' => 3 }
+    hash = R18n::Utils.hash_map({ 'a' => 1, 'b' => 2 }) { |k, v|
+      [k + 'a', v + 1]
+    }
+    expect(hash).to eq({ 'aa' => 2, 'ba' => 3 })
   end
 
   it "merges hash recursively" do
-    a = { :a => 1, :b => {:ba => 1, :bb => 1}, :c => 1 }
-    b = {          :b => {:bb => 2, :bc => 2}, :c => 2 }
+    a = { a: 1, b: { ba: 1, bb: 1}, c: 1 }
+    b = {       b: { bb: 2, bc: 2}, c: 2 }
 
     R18n::Utils.deep_merge!(a, b)
-    a.should == { :a => 1, :b => { :ba => 1, :bb => 2, :bc => 2 }, :c => 2 }
+    expect(a).to eq({ a: 1, b: { ba: 1, bb: 2, bc: 2 }, c: 2 })
   end
 
   it "has l and t methods" do
     R18n.set('en')
-    t.yes.should == 'Yes'
-    l(Time.at(0).utc).should == '01/01/1970 00:00'
+    expect(t.yes).to eq('Yes')
+    expect(l(Time.at(0).utc)).to eq('01/01/1970 00:00')
   end
 
   it "has helpers mixin" do
     obj = R18n::I18n.new('en')
     R18n.set(obj)
 
-    r18n.should  == obj
-    i18n.should  == obj
-    t.yes.should == 'Yes'
-    l(Time.at(0).utc).should == '01/01/1970 00:00'
+    expect(r18n).to  eq(obj)
+    expect(i18n).to  eq(obj)
+    expect(t.yes).to eq('Yes')
+    expect(l(Time.at(0).utc)).to eq('01/01/1970 00:00')
   end
 
   it "returns available translations" do
-    R18n.available_locales(DIR).should =~ [R18n.locale('nolocale'),
+    expect(R18n.available_locales(DIR)).to match_array([R18n.locale('nolocale'),
                                            R18n.locale('ru'),
-                                           R18n.locale('en')]
+                                           R18n.locale('en')])
   end
 
   it "uses default places" do
     R18n.default_places = DIR
     R18n.set('en')
-    t.one.should == 'One'
-    R18n.available_locales.should =~ [R18n.locale('ru'),
+    expect(t.one).to eq('One')
+    expect(R18n.available_locales).to match_array([R18n.locale('ru'),
                                       R18n.locale('en'),
-                                      R18n.locale('nolocale')]
+                                      R18n.locale('nolocale')])
   end
 
   it "sets default places by block" do
     R18n.default_places { DIR }
-    R18n.default_places.should == DIR
+    expect(R18n.default_places).to eq(DIR)
   end
 
   it "allows to ignore default places" do
     R18n.default_places = DIR
     i18n = R18n::I18n.new('en', nil)
-    i18n.one.should_not be_translated
+    expect(i18n.one).not_to be_translated
   end
-
 end

data/spec/spec_helper.rb

@@ -1,4 +1,3 @@
-# encoding: utf-8
 require 'pp'
 
 dir = Pathname(__FILE__).dirname
@@ -36,9 +35,3 @@ class CounterLoader
     @available.hash
   end
 end
-
-RSpec.configure do |c|
-  c.filter_run_excluding :not_ruby => lambda { |version|
-    RUBY_VERSION.to_s.start_with? version.to_s
-  }
-end

data/spec/translated_spec.rb

@@ -1,4 +1,3 @@
-# encoding: utf-8
 require File.expand_path('../spec_helper', __FILE__)
 
 describe R18n::Translated do
@@ -14,17 +13,17 @@ describe R18n::Translated do
   end
 
   it "saves methods map" do
-    @user_class.translation :name, :methods => { :ru => :name_ru }
-    @user_class.unlocalized_getters(:name).should == { 'ru' => 'name_ru' }
-    @user_class.unlocalized_setters(:name).should == { 'ru' => 'name_ru=' }
+    @user_class.translation :name, methods: { ru: :name_ru }
+    expect(@user_class.unlocalized_getters(:name)).to eq({ 'ru' => 'name_ru' })
+    expect(@user_class.unlocalized_setters(:name)).to eq({ 'ru' => 'name_ru=' })
   end
 
   it "autodetects methods map" do
     @user_class.translation :name
-    @user_class.unlocalized_getters(:name).should == {
-        'en' => 'name_en', 'ru' => 'name_ru' }
-    @user_class.unlocalized_setters(:name).should == {
-        'en' => 'name_en=', 'ru' => 'name_ru=' }
+    expect(@user_class.unlocalized_getters(:name)).to eq({
+        'en' => 'name_en', 'ru' => 'name_ru' })
+    expect(@user_class.unlocalized_setters(:name)).to eq({
+        'en' => 'name_en=', 'ru' => 'name_ru=' })
   end
 
   it "translates methods" do
@@ -32,12 +31,12 @@ describe R18n::Translated do
     user = @user_class.new
 
     user.name = 'John'
-    user.name.should == 'John'
+    expect(user.name).to eq('John')
 
     R18n.set('ru')
-    user.name.should == 'John'
+    expect(user.name).to eq('John')
     user.name = 'Джон'
-    user.name.should == 'Джон'
+    expect(user.name).to eq('Джон')
   end
 
   it "returns TranslatedString" do
@@ -48,9 +47,9 @@ describe R18n::Translated do
     end
     obj = ::SomeTranslatedClass.new
 
-    obj.name.should be_a(R18n::TranslatedString)
-    obj.name.locale.should == R18n.locale('en')
-    obj.name.path.should == 'SomeTranslatedClass#name'
+    expect(obj.name).to be_kind_of(R18n::TranslatedString)
+    expect(obj.name.locale).to eq(R18n.locale('en'))
+    expect(obj.name.path).to eq('SomeTranslatedClass#name')
   end
 
   it "searchs translation by locales priority" do
@@ -59,7 +58,7 @@ describe R18n::Translated do
 
     R18n.set(['nolocale', 'ru', 'en'])
     user.name_ru = 'Иван'
-    user.name.locale.should == R18n.locale('ru')
+    expect(user.name.locale).to eq(R18n.locale('ru'))
   end
 
   it "uses default locale" do
@@ -68,42 +67,42 @@ describe R18n::Translated do
 
     R18n.set('nolocale')
     user.name_en = 'John'
-    user.name.locale.should == R18n.locale('en')
+    expect(user.name.locale).to eq(R18n.locale('en'))
   end
 
   it "uses filters" do
     @user_class.class_eval do
       def age_en; {1 => '%1 year', 'n' => '%1 years'} end
-      translation :age, :type => 'pl', :no_params => true
+      translation :age, type: 'pl', no_params: true
     end
     user = @user_class.new
 
-    user.age(20).should == '20 years'
+    expect(user.age(20)).to eq('20 years')
   end
 
   it "sends params to method if user want it" do
     @user_class.class_eval do
       def no_params_en(*params) params.join(' '); end
       def params_en(*params)    params.join(' '); end
-      translations [:no_params, {:no_params => true}], :params
+      translations [:no_params, { no_params: true }], :params
     end
     user = @user_class.new
 
-    user.no_params(1, 2).should == ''
-    user.params(1, 2).should == '1 2'
+    expect(user.no_params(1, 2)).to eq('')
+    expect(user.params(1, 2)).to eq('1 2')
   end
 
   it "translates virtual methods" do
     @virtual_class = Class.new do
       include R18n::Translated
-      translation :no_method, :methods => { :en => :no_method_en }
+      translation :no_method, methods: { en: :no_method_en }
       def method_missing(name, *params)
         name.to_s
       end
     end
     virtual = @virtual_class.new
 
-    virtual.no_method.should == 'no_method_en'
+    expect(virtual.no_method).to eq('no_method_en')
   end
 
   it "returns original type of result" do
@@ -115,7 +114,7 @@ describe R18n::Translated do
     end
     user = @user_class.new
 
-    user.name.should == :ivan
+    expect(user.name).to eq(:ivan)
   end
 
   it "returns nil" do
@@ -127,7 +126,7 @@ describe R18n::Translated do
     end
     user = @user_class.new
 
-    user.name.should be_nil
+    expect(user.name).to be_nil
   end
 
   it "allows to change I18n object" do
@@ -140,9 +139,8 @@ describe R18n::Translated do
     user.name_en = 'John'
 
     user.r18n = R18n::I18n.new('ru')
-    user.name.should == 'Иван'
+    expect(user.name).to eq('Иван')
     user.r18n = R18n::I18n.new('en')
-    user.name.should == 'John'
+    expect(user.name).to eq('John')
   end
-
 end