twitter_cldr 3.0.1 → 3.0.2

data/spec/localized/localized_number_spec.rb

@@ -14,16 +14,16 @@ describe LocalizedNumber do
     let(:currency) { LocalizedNumber.new(10, :en, :type => :currency) }
 
     it 'uses nil type by default (defers decision to data reader)' do
-      decimal.type.should == nil
+      expect(decimal.type).to eq(nil)
     end
 
     it 'uses provided type if there is one' do
-      currency.type.should == :currency
+      expect(currency.type).to eq(:currency)
     end
 
     it 'sets up object with correct locale, falls back to default locale' do
-      LocalizedNumber.new(10, :es).locale.should == :es
-      LocalizedNumber.new(10, :blarg).locale.should == TwitterCldr::DEFAULT_LOCALE
+      expect(LocalizedNumber.new(10, :es).locale).to eq(:es)
+      expect(LocalizedNumber.new(10, :blarg).locale).to eq(TwitterCldr::DEFAULT_LOCALE)
     end
   end
 
@@ -36,20 +36,20 @@ describe LocalizedNumber do
         let(:method) { "to_#{type}" }
 
         it 'creates a new object' do
-          number.send(method).object_id.should_not == number.object_id
+          expect(number.send(method).object_id).not_to eq(number.object_id)
         end
 
         it 'creates an object of the appropriate type, but does not change the type of the original object' do
           new_number = currency.send(method)
-          new_number.type.should == type
-          currency.type.should == :currency
+          expect(new_number.type).to eq(type)
+          expect(currency.type).to eq(:currency)
         end
 
         it 'creates a new object with the same base object and locale' do
           percent = LocalizedNumber.new(42, :fr, :type => :percent)
           new_percent = percent.send(method)
-          new_percent.locale.should == :fr
-          new_percent.base_obj.should == 42
+          expect(new_percent.locale).to eq(:fr)
+          expect(new_percent.base_obj).to eq(42)
         end
       end
     end
@@ -57,20 +57,20 @@ describe LocalizedNumber do
 
   describe '#to_s' do
     it 'raises ArguemntError if unsupported type is passed' do
-      lambda do
+      expect do
         LocalizedNumber.new(10, :en, :type => :foo).to_s
-      end.should raise_error(ArgumentError, 'Type foo is not supported')
+      end.to raise_error(ArgumentError, 'Type foo is not supported')
     end
 
     context 'decimals' do
       let(:number) { LocalizedNumber.new(10, :en) }
 
       it 'should default precision to zero' do
-        number.to_s.should == "10"
+        expect(number.to_s).to eq("10")
       end
 
       it 'should not overwrite precision when explicitly passed' do
-        number.to_s(:precision => 2).should == "10.00"
+        expect(number.to_s(:precision => 2)).to eq("10.00")
       end
     end
 
@@ -78,11 +78,11 @@ describe LocalizedNumber do
       let(:number) { LocalizedNumber.new(10, :en, :type => :currency) }
 
       it "should default to a precision of 2" do
-        number.to_s(:precision => 2).should == "$10.00"
+        expect(number.to_s(:precision => 2)).to eq("$10.00")
       end
 
       it 'should not overwrite precision when explicitly passed' do
-        number.to_s(:precision => 1).should == "$10.0"
+        expect(number.to_s(:precision => 1)).to eq("$10.0")
       end
     end
 
@@ -90,11 +90,11 @@ describe LocalizedNumber do
       let(:number) { LocalizedNumber.new(10, :en, :type => :percent) }
 
       it "should default to a precision of 0" do
-        number.to_s.should == "10%"
+        expect(number.to_s).to eq("10%")
       end
 
       it 'should not overwrite precision when explicitly passed' do
-        number.to_s(:precision => 1).should == "10.0%"
+        expect(number.to_s(:precision => 1)).to eq("10.0%")
       end
     end
 
@@ -102,11 +102,11 @@ describe LocalizedNumber do
       let(:number) { LocalizedNumber.new(1000, :en, :type => :short_decimal) }
 
       it "should default to a precision of 0" do
-        number.to_s.should == "1K"
+        expect(number.to_s).to eq("1K")
       end
 
       it 'should not overwrite precision when explicitly passed' do
-        number.to_s(:precision => 1).should == "1.0K"
+        expect(number.to_s(:precision => 1)).to eq("1.0K")
       end
     end
 
@@ -114,57 +114,57 @@ describe LocalizedNumber do
       let(:number) { LocalizedNumber.new(1000, :en, :type => :long_decimal) }
 
       it "should default to a precision of 0" do
-        number.to_s.should == "1 thousand"
+        expect(number.to_s).to eq("1 thousand")
       end
 
       it 'should not overwrite precision when explicitly passed' do
-        number.to_s(:precision => 1).should == "1.0 thousand"
+        expect(number.to_s(:precision => 1)).to eq("1.0 thousand")
       end
     end
   end
 
   describe '#plural_rule' do
     it 'returns the appropriate plural rule for the number' do
-      1.localize(:ru).plural_rule.should == :one
-      2.localize(:ru).plural_rule.should == :other
-      5.localize(:ru).plural_rule.should == :many
+      expect(1.localize(:ru).plural_rule).to eq(:one)
+      expect(2.localize(:ru).plural_rule).to eq(:other)
+      expect(5.localize(:ru).plural_rule).to eq(:many)
     end
 
     it 'takes FastGettext.locale into account' do
       FastGettext.locale = :es
-      1.localize.plural_rule.should == :one
-      2.localize.plural_rule.should == :other
-      5.localize.plural_rule.should == :other
+      expect(1.localize.plural_rule).to eq(:one)
+      expect(2.localize.plural_rule).to eq(:other)
+      expect(5.localize.plural_rule).to eq(:other)
     end
   end
 
   describe 'formatters for every locale' do
     it "makes sure currency formatters for every locale don't raise errors" do
       TwitterCldr.supported_locales.each do |locale|
-        lambda { 1337.localize(locale).to_currency.to_s }.should_not raise_error
-        lambda { 1337.localize(locale).to_currency.to_s(:precision => 3) }.should_not raise_error
-        lambda { 1337.localize(locale).to_currency.to_s(:precision => 3, :currency => "EUR") }.should_not raise_error
+        expect { 1337.localize(locale).to_currency.to_s }.not_to raise_error
+        expect { 1337.localize(locale).to_currency.to_s(:precision => 3) }.not_to raise_error
+        expect { 1337.localize(locale).to_currency.to_s(:precision => 3, :currency => "EUR") }.not_to raise_error
       end
     end
 
     it "makes sure decimal formatters for every locale don't raise errors" do
       TwitterCldr.supported_locales.each do |locale|
-        lambda { 1337.localize(locale).to_decimal.to_s }.should_not raise_error
-        lambda { 1337.localize(locale).to_decimal.to_s(:precision => 3) }.should_not raise_error
+        expect { 1337.localize(locale).to_decimal.to_s }.not_to raise_error
+        expect { 1337.localize(locale).to_decimal.to_s(:precision => 3) }.not_to raise_error
       end
     end
 
     it "makes sure percentage formatters for every locale don't raise errors" do
       TwitterCldr.supported_locales.each do |locale|
-        lambda { 1337.localize(locale).to_percent.to_s }.should_not raise_error
-        lambda { 1337.localize(locale).to_percent.to_s(:precision => 3) }.should_not raise_error
+        expect { 1337.localize(locale).to_percent.to_s }.not_to raise_error
+        expect { 1337.localize(locale).to_percent.to_s(:precision => 3) }.not_to raise_error
       end
     end
 
     it "makes sure basic number formatters for every locale don't raise errors" do
       TwitterCldr.supported_locales.each do |locale|
-        lambda { 1337.localize(locale).to_s }.should_not raise_error
-        lambda { 1337.localize(locale).to_s(:precision => 3) }.should_not raise_error
+        expect { 1337.localize(locale).to_s }.not_to raise_error
+        expect { 1337.localize(locale).to_s(:precision => 3) }.not_to raise_error
       end
     end
   end

data/spec/localized/localized_object_spec.rb

@@ -26,23 +26,23 @@ describe LocalizedObject do
     let(:options) { { :foobar => 'value' } }
 
     it 'sets base object' do
-      localized_object.base_obj.should == base_object
+      expect(localized_object.base_obj).to eq(base_object)
     end
 
     it 'sets locale' do
-      localized_object.locale.should == locale
+      expect(localized_object.locale).to eq(locale)
     end
 
     it 'converts locale' do
-      LocalizedClass.new(base_object, :msa).locale.should == :ms
+      expect(LocalizedClass.new(base_object, :msa).locale).to eq(:ms)
     end
 
     it 'falls back to default locale if unsupported locale is passed' do
-      LocalizedClass.new(base_object, :foobar).locale.should == TwitterCldr::DEFAULT_LOCALE
+      expect(LocalizedClass.new(base_object, :foobar).locale).to eq(TwitterCldr::DEFAULT_LOCALE)
     end
 
     it "doesn't change original options hash" do
-      lambda { LocalizedClass.new(base_object, locale, options) }.should_not change { options }
+      expect { LocalizedClass.new(base_object, locale, options) }.not_to change { options }
     end
   end
 
@@ -50,9 +50,9 @@ describe LocalizedObject do
     it 'defines #localize method on a class' do
       some_class = Class.new
 
-      some_class.new.should_not respond_to(:localize)
+      expect(some_class.new).not_to respond_to(:localize)
       LocalizedClass.localize(some_class)
-      some_class.new.should respond_to(:localize)
+      expect(some_class.new).to respond_to(:localize)
     end
   end
 
@@ -67,7 +67,7 @@ describe LocalizedObject do
     end
 
     it 'returns localized object' do
-      localizable_object.localize.should be_a(LocalizedClass)
+      expect(localizable_object.localize).to be_a(LocalizedClass)
     end
 
     it 'accepts locale and options and pass them to the localized class constructor' do

data/spec/localized/localized_string_spec.rb

@@ -11,19 +11,19 @@ describe LocalizedString do
   describe '#%' do
     context 'when argument is not a Hash' do
       it 'performs regular formatting of values' do
-        ('%d is an integer'.localize % 3.14).should == '3 is an integer'
+        expect('%d is an integer'.localize % 3.14).to eq('3 is an integer')
       end
 
       it 'performs regular formatting of arrays' do
-        ('"% 04d" is a %s'.localize % [12, 'number']).should == '" 012" is a number'
+        expect('"% 04d" is a %s'.localize % [12, 'number']).to eq('" 012" is a number')
       end
 
       it 'ignores pluralization placeholders' do
-        ('%s: %{horses_count:horses}'.localize % 'total').should == 'total: %{horses_count:horses}'
+        expect('%s: %{horses_count:horses}'.localize % 'total').to eq('total: %{horses_count:horses}')
       end
 
       it 'raises ArgumentError when the string contains named placeholder' do
-        lambda { '%{msg}: %{horses_count:horses}'.localize % 'total' }.should raise_error(ArgumentError)
+        expect { '%{msg}: %{horses_count:horses}'.localize % 'total' }.to raise_error(ArgumentError)
       end
     end
 
@@ -35,47 +35,47 @@ describe LocalizedString do
       end
 
       it 'interpolates named placeholders' do
-        ('%<num>.2f is a %{noun}'.localize % { :num => 3.1415, :noun => 'number' }).should == '3.14 is a number'
+        expect('%<num>.2f is a %{noun}'.localize % { :num => 3.1415, :noun => 'number' }).to eq('3.14 is a number')
       end
 
       it 'performs regular pluralization' do
-        ('%{horses_count:horses}'.localize % { :horses_count => 2, :horses => horses }).should == '2 horses'
+        expect('%{horses_count:horses}'.localize % { :horses_count => 2, :horses => horses }).to eq('2 horses')
       end
 
       it 'performs inline pluralization' do
         string = '%<{ "horses_count": { "other": "%{horses_count} horses" } }>'.localize
-        (string % { :horses_count => 2 }).should == '2 horses'
+        expect(string % { :horses_count => 2 }).to eq('2 horses')
       end
 
       it 'performs both formatting and regular pluralization simultaneously' do
         string = '%{msg}: %{horses_count:horses}'.localize
-        (string % { :horses_count => 2, :horses => horses, :msg => 'result' }).should == 'result: 2 horses'
+        expect(string % { :horses_count => 2, :horses => horses, :msg => 'result' }).to eq('result: 2 horses')
       end
 
       it 'performs both formatting and inline pluralization simultaneously' do
         string = '%{msg}: %<{"horses_count": {"other": "%{horses_count} horses"}}>'.localize
-        (string % { :horses_count => 2, :msg => 'result' }).should == 'result: 2 horses'
+        expect(string % { :horses_count => 2, :msg => 'result' }).to eq('result: 2 horses')
       end
 
       it 'performs both formatted interpolation and inline pluralization simultaneously' do
         string = '%<number>d, %<{"horses_count": {"other": "%{horses_count} horses" }}>'.localize
-        (string % { :number => 3.14, :horses_count => 2 }).should == '3, 2 horses'
+        expect(string % { :number => 3.14, :horses_count => 2 }).to eq('3, 2 horses')
       end
 
       it 'leaves regular pluralization placeholders unchanged if not enough information given' do
         string = '%{msg}: %{horses_count:horses}'.localize
-        (string % { :msg => 'no pluralization' } ).should == 'no pluralization: %{horses_count:horses}'
+        expect(string % { :msg => 'no pluralization' } ).to eq('no pluralization: %{horses_count:horses}')
       end
 
       it 'leaves inline pluralization placeholders unchanged if not enough information given' do
         string = '%<number>d, %<{"horses_count": {"one": "one horse"}}>'.localize
-        (string % { :number => 3.14, :horses_count => 2 }).should == '3, %<{"horses_count": {"one": "one horse"}}>'
+        expect(string % { :number => 3.14, :horses_count => 2 }).to eq('3, %<{"horses_count": {"one": "one horse"}}>')
       end
 
       it 'raises KeyError when value for a named placeholder is missing' do
-        lambda do
+        expect do
           '%{msg}: %{horses_count:horses}'.localize % { :horses_count => 2, :horses => horses }
-        end.should raise_error(KeyError)
+        end.to raise_error(KeyError)
       end
     end
   end
@@ -85,41 +85,41 @@ describe LocalizedString do
       string = "galoshes"
       result = string.localize.to_s
 
-      result.should == string
-      result.equal?(string).should_not be_true
+      expect(result).to eq(string)
+      expect(result.equal?(string)).not_to be_true
     end
   end
 
   describe "#to_f" do
     it "should correctly parse a number with a thousands separator" do
-      "1,300".localize.to_f.should == 1300.0
-      "1.300".localize(:es).to_f.should == 1300.0
+      expect("1,300".localize.to_f).to eq(1300.0)
+      expect("1.300".localize(:es).to_f).to eq(1300.0)
     end
 
     it "should correctly parse a number with a decimal separator" do
-      "1.300".localize.to_f.should == 1.3
-      "1,300".localize(:es).to_f.should == 1.3
+      expect("1.300".localize.to_f).to eq(1.3)
+      expect("1,300".localize(:es).to_f).to eq(1.3)
     end
 
     it "should correctly parse a number with a thousands and a decimal separator" do
-      "1,300.05".localize.to_f.should == 1300.05
-      "1.300,05".localize(:es).to_f.should == 1300.05
+      expect("1,300.05".localize.to_f).to eq(1300.05)
+      expect("1.300,05".localize(:es).to_f).to eq(1300.05)
     end
 
     it "should return zero if the string contains no numbers" do
-      "abc".localize.to_f.should == 0.0
+      expect("abc".localize.to_f).to eq(0.0)
     end
 
     it "should return only the numbers at the beginning of the string if the string contains any non-numeric characters" do
-      "1abc".localize.to_f.should == 1.0
-      "a1bc".localize.to_f.should == 0.0
+      expect("1abc".localize.to_f).to eq(1.0)
+      expect("a1bc".localize.to_f).to eq(0.0)
     end
   end
 
   describe "#to_i" do
     it "should chop off the decimal" do
-      "1,300.05".localize.to_i.should == 1300
-      "1.300,05".localize(:es).to_i.should == 1300
+      expect("1,300.05".localize.to_i).to eq(1300)
+      expect("1.300,05".localize(:es).to_i).to eq(1300)
     end
   end
 
@@ -129,65 +129,65 @@ describe LocalizedString do
     let(:localized_string) { string.localize }
 
     it 'returns a LocalizedString' do
-      localized_string.normalize.should be_an_instance_of(LocalizedString)
+      expect(localized_string.normalize).to be_an_instance_of(LocalizedString)
     end
 
     it 'it uses NFD by default' do
       mock(Eprun).normalize(string, :nfd) { normalized_string }
-      localized_string.normalize.base_obj.should == normalized_string
+      expect(localized_string.normalize.base_obj).to eq(normalized_string)
     end
 
     it "uses specified algorithm if there is any" do
       mock(Eprun).normalize(string, :nfkd) { normalized_string }
-      localized_string.normalize(:using => :NFKD).base_obj.should == normalized_string
+      expect(localized_string.normalize(:using => :NFKD).base_obj).to eq(normalized_string)
     end
 
     it "raises an ArgumentError if passed an unsupported normalization form" do
-      lambda { localized_string.normalize(:using => :blarg) }.should raise_error(ArgumentError)
+      expect { localized_string.normalize(:using => :blarg) }.to raise_error(ArgumentError)
     end
   end
 
   describe "#casefold" do
     it 'returns a LocalizedString' do
       str = "Weißrussland".localize.casefold
-      str.should be_an_instance_of(LocalizedString)
-      str.to_s.should == "weissrussland"
+      expect(str).to be_an_instance_of(LocalizedString)
+      expect(str.to_s).to eq("weissrussland")
     end
 
     it 'does not pass the t option by default' do
-      "Istanbul".localize.casefold.to_s.should == "istanbul"
+      expect("Istanbul".localize.casefold.to_s).to eq("istanbul")
     end
 
     it 'uses the t option when explicitly given' do
-      "Istanbul".localize.casefold(:t => true).to_s.should == "ıstanbul"
+      expect("Istanbul".localize.casefold(:t => true).to_s).to eq("ıstanbul")
     end
 
     it 'uses t by default if the locale is tr (az not supported)' do
-      "Istanbul".localize(:tr).casefold.to_s.should == "ıstanbul"
+      expect("Istanbul".localize(:tr).casefold.to_s).to eq("ıstanbul")
     end
   end
 
   describe "#each_sentence" do
     it "returns an enumerator if not passed a block" do
-      "foo bar".localize.each_sentence.should be_a(Enumerator)
+      expect("foo bar".localize.each_sentence).to be_a(Enumerator)
     end
 
     it "yields sentences as localized strings" do
       str = "Quick. Brown. Fox.".localize
 
       str.each_sentence do |sentence|
-        sentence.should be_a(LocalizedString)
+        expect(sentence).to be_a(LocalizedString)
       end
 
-      str.each_sentence.to_a.map(&:to_s).should == [
+      expect(str.each_sentence.to_a.map(&:to_s)).to eq([
         "Quick.", " Brown.", " Fox."
-      ]
+      ])
     end
   end
 
   describe "#code_points" do
     it "returns an array of Unicode code points for the string" do
-      "español".localize.code_points.should == [0x65, 0x73, 0x70, 0x61, 0xF1, 0x6F, 0x6C]
+      expect("español".localize.code_points).to eq([0x65, 0x73, 0x70, 0x61, 0xF1, 0x6F, 0x6C])
     end
   end
 
@@ -197,34 +197,34 @@ describe LocalizedString do
       str = "twitter"
 
       str.localize.each_char do |char|
-        str.chars.to_a[index].should == char
+        expect(str.chars.to_a[index]).to eq(char)
         index += 1
       end
     end
 
     it "returns an enumerator if no block is given" do
-      "twitter".localize.each_char.should be_a(Enumerator)
+      expect("twitter".localize.each_char).to be_a(Enumerator)
     end
 
     it "responds to a few other methods from Enumerable" do
       upcased = "twitter".localize.map { |letter| letter.upcase }
-      upcased.size.should == 7
-      upcased.join.should == "TWITTER"
+      expect(upcased.size).to eq(7)
+      expect(upcased.join).to eq("TWITTER")
 
-      "twitter".localize.inject("") { |str, letter| str = "#{letter}#{str}"; str }.should == "rettiwt"
+      expect("twitter".localize.inject("") { |str, letter| str = "#{letter}#{str}"; str }).to eq("rettiwt")
     end
   end
 
   describe "#to_yaml" do
     it "should be able to successfully roundtrip the string" do
-      YAML.load("coolio".localize.to_yaml).should == "coolio"
-      YAML.load("coolió".localize.to_yaml).should == "coolió"
+      expect(YAML.load("coolio".localize.to_yaml)).to eq("coolio")
+      expect(YAML.load("coolió".localize.to_yaml)).to eq("coolió")
     end
   end
 
   describe "#to_bidi" do
     it "should return an instance of TwitterCldr::Shared::Bidi" do
-      "abc".localize.to_bidi.should be_a(TwitterCldr::Shared::Bidi)
+      expect("abc".localize.to_bidi).to be_a(TwitterCldr::Shared::Bidi)
     end
   end
 
@@ -232,13 +232,13 @@ describe LocalizedString do
     it "should reverse the order a basic RTL string" do
       str = "{0} \331\210 {1}".gsub("{0}", "a").gsub("{1}", "b")
       chars = str.chars.to_a
-      chars.first.should == "a"
-      chars.last.should == "b"
+      expect(chars.first).to eq("a")
+      expect(chars.last).to eq("b")
 
       result = str.localize.to_reordered_s(:direction => :RTL)
       result_chars = result.chars.to_a
-      result_chars.first.should == "b"
-      result_chars.last.should == "a"
+      expect(result_chars.first).to eq("b")
+      expect(result_chars.last).to eq("a")
     end
   end
 

data/spec/localized/localized_symbol_spec.rb

@@ -11,27 +11,27 @@ describe LocalizedSymbol do
 
   describe "#as_language_code" do
     it "returns the correct localized language from the symbol" do
-      :es.localize.as_language_code.should == "Spanish"
+      expect(:es.localize.as_language_code).to eq("Spanish")
       TwitterCldr.locale = :es
-      :es.localize.as_language_code.should == "español"
+      expect(:es.localize.as_language_code).to eq("español")
     end
 
     it "returns nil if the symbol doesn't correspond to a language code" do
-      :blarg.localize.as_language_code.should == nil
+      expect(:blarg.localize.as_language_code).to eq(nil)
     end
 
     it "returns the correct value for mapped as well as CLDR language codes" do
-      :'zh-cn'.localize.as_language_code.should == "Chinese"
-      :'zh-tw'.localize.as_language_code.should == "Traditional Chinese"
-      :'zh-Hant'.localize.as_language_code.should == "Traditional Chinese"
-      :'zh'.localize.as_language_code.should == "Chinese"
+      expect(:'zh-cn'.localize.as_language_code).to eq("Chinese")
+      expect(:'zh-tw'.localize.as_language_code).to eq("Traditional Chinese")
+      expect(:'zh-Hant'.localize.as_language_code).to eq("Traditional Chinese")
+      expect(:'zh'.localize.as_language_code).to eq("Chinese")
     end
   end
 
   describe "#is_rtl?" do
     it "should return true or false depending on the locale" do
-      :es.localize.is_rtl?.should be_false
-      :ar.localize.is_rtl?.should be_true
+      expect(:es.localize.is_rtl?).to be_false
+      expect(:ar.localize.is_rtl?).to be_true
     end
   end
 

data/spec/localized/localized_time_spec.rb

@@ -20,7 +20,7 @@ describe LocalizedTime do
 
     it "should stringify with buddhist calendar" do
       # Ensure that buddhist calendar data is present in th locale.
-      TwitterCldr.get_locale_resource(:th, :calendars)[:th][:calendars][:buddhist].should_not(
+      expect(TwitterCldr.get_locale_resource(:th, :calendars)[:th][:calendars][:buddhist]).not_to(
           be_nil, 'buddhist calendar is missing for :th locale (check resources/locales/th/calendars.yml)'
       )
 
@@ -33,7 +33,7 @@ describe LocalizedTime do
 
   describe "#ago" do
     it "should return a localized timespan" do
-      time.localize(:de).ago.should be_a(LocalizedTimespan)
+      expect(time.localize(:de).ago).to be_a(LocalizedTimespan)
     end
   end
 
@@ -42,16 +42,16 @@ describe LocalizedTime do
       date = Date.new(1987, 9, 20)
       time = Time.local(2000, 5, 12, 22, 5)
       datetime = time.localize.to_datetime(date)
-      datetime.should be_a(LocalizedDateTime)
-      datetime.base_obj.strftime("%Y-%m-%d %H:%M:%S").should == "1987-09-20 22:05:00"
+      expect(datetime).to be_a(LocalizedDateTime)
+      expect(datetime.base_obj.strftime("%Y-%m-%d %H:%M:%S")).to eq("1987-09-20 22:05:00")
     end
 
     it "should work with an instance of LocalizedDate too" do
       date = DateTime.new(1987, 9, 20, 0, 0, 0).localize.to_date
       time = Time.local(2000, 5, 12, 22, 5)
       datetime = time.localize.to_datetime(date)
-      datetime.should be_a(LocalizedDateTime)
-      datetime.base_obj.strftime("%Y-%m-%d %H:%M:%S").should == "1987-09-20 22:05:00"
+      expect(datetime).to be_a(LocalizedDateTime)
+      expect(datetime.base_obj.strftime("%Y-%m-%d %H:%M:%S")).to eq("1987-09-20 22:05:00")
     end
   end
 
@@ -59,7 +59,7 @@ describe LocalizedTime do
     it "don't raise errors for any locale" do
       TwitterCldr.supported_locales.each do |locale|
         (CalendarDataReader.types - [:additional]).each do |type|
-          lambda { Time.now.localize(locale).send(:"to_#{type}_s") }.should_not raise_error
+          expect { Time.now.localize(locale).send(:"to_#{type}_s") }.not_to raise_error
         end
       end
     end
@@ -68,9 +68,9 @@ describe LocalizedTime do
   describe "#with_timezone" do
     it "calculates the right time depending on the timezone" do
       time = Time.utc(2000, 5, 12, 22, 5).localize
-      time.to_s.should == "10:05:00 PM"
-      time.with_timezone("America/Los_Angeles").to_s.should == "3:05:00 PM"
-      time.with_timezone("America/New_York").to_s.should == "6:05:00 PM"
+      expect(time.to_s).to eq("10:05:00 PM")
+      expect(time.with_timezone("America/Los_Angeles").to_s).to eq("3:05:00 PM")
+      expect(time.with_timezone("America/New_York").to_s).to eq("6:05:00 PM")
     end
   end