twitter_cldr 3.0.1 → 3.0.2

data/spec/formatters/plurals/plural_formatter_spec.rb

@@ -11,11 +11,11 @@ describe PluralFormatter do
 
   describe '#initialize' do
     it 'fetches locale from options hash' do
-      PluralFormatter.new(:ru).locale.should == :ru
+      expect(PluralFormatter.new(:ru).locale).to eq(:ru)
     end
 
     it "uses current locale if it's not passed in options hash" do
-      PluralFormatter.new.locale.should == TwitterCldr.locale
+      expect(PluralFormatter.new.locale).to eq(TwitterCldr.locale)
     end
   end
 
@@ -38,47 +38,47 @@ describe PluralFormatter do
     context 'when there is nothing to pluralize' do
       it "doesn't change the string if no interpolation found" do
         string = 'no interpolation here'
-        subject.format(string, {}).should == string
+        expect(subject.format(string, {})).to eq(string)
       end
 
       context 'with regular pluralization' do
         it "doesn't change the string if a number is not provided" do
           string = 'there %{horses_count:horses}'
-          subject.format(string, :horses => horses).should == string
+          expect(subject.format(string, :horses => horses)).to eq(string)
         end
 
         it "doesn't change the string if a patterns hash is not provided" do
           string = 'there %{horses_count:horses}'
-          subject.format(string, :horses_count => 1).should == string
+          expect(subject.format(string, :horses_count => 1)).to eq(string)
         end
 
         it "doesn't change the string if required pattern is not provided" do
           string = 'there %{horses_count:horses}'
-          subject.format(string, :horses_count => 2, :horses => { :one => 'is 1 horse' }).should == string
+          expect(subject.format(string, :horses_count => 2, :horses => { :one => 'is 1 horse' })).to eq(string)
         end
       end
 
       context 'with inline pluralization' do
         it "doesn't change the string if a number is not provided" do
           string = "there #{horses_string}"
-          subject.format(string, {}).should == string
+          expect(subject.format(string, {})).to eq(string)
         end
 
         it "doesn't change the string if required pattern is not provided" do
           string = 'there %<{ "horses_count": {"one": "is 1 horse"} }>'
-          subject.format(string, :horses_count => 2).should == string
+          expect(subject.format(string, :horses_count => 2)).to eq(string)
         end
       end
 
       context 'with mixed pluralization' do
         it "doesn't change the string if a number is not provided" do
           string = "there #{horses_string} %{horses_count:horses}"
-          subject.format(string, :horses => horses).should == string
+          expect(subject.format(string, :horses => horses)).to eq(string)
         end
 
         it "doesn't change the string if required pattern is not provided" do
           string = 'there %<{ "horses_count": {"one": "is 1 horse"} }> %{horses_count:horses}'
-          subject.format(string, :horses_count => 2, :horses => { :one => 'is 1 horse' }).should == string
+          expect(subject.format(string, :horses_count => 2, :horses => { :one => 'is 1 horse' })).to eq(string)
         end
       end
     end
@@ -86,109 +86,109 @@ describe PluralFormatter do
     context 'when something should be pluralized' do
       context 'with regular pluralization' do
         it 'pluralizes with a simple replacement' do
-          subject.format(
+          expect(subject.format(
               'there %{horses_count:horses}',
               :horses_count => 1, :horses => horses
-          ).should == 'there is 1 horse'
+          )).to eq('there is 1 horse')
         end
 
         it 'pluralizes when there are named interpolation patterns in the string' do
-          subject.format(
+          expect(subject.format(
               '%{there} %{horses_count:horses}',
               :horses_count => 1, :horses => horses
-          ).should == '%{there} is 1 horse'
+          )).to eq('%{there} is 1 horse')
         end
 
         it 'supports multiple patterns sets for the same number' do
-          subject.format(
+          expect(subject.format(
               'there %{horses_count:to_be} %{horses_count:horses}',
               :horses_count => 1, :horses => simple_horses, :to_be => to_be
-          ).should == 'there is 1 horse'
+          )).to eq('there is 1 horse')
         end
 
         it 'pluralizes multiple entries' do
-          subject.format(
+          expect(subject.format(
               'there %{yaks_count:yaks} and %{horses_count:horses}',
               :yaks_count => 1, :yaks => yaks, :horses_count => 2, :horses => simple_horses
-          ).should == 'there is 1 yak and 2 horses'
+          )).to eq('there is 1 yak and 2 horses')
         end
 
         it 'substitutes the number for a placeholder in the pattern' do
-          subject.format(
+          expect(subject.format(
               'there %{horses_count:horses}',
               :horses_count => 3, :horses => horses
-          ).should == 'there are 3 horses'
+          )).to eq('there are 3 horses')
         end
 
         it 'substitutes the number for multiple placeholders in the pattern' do
-          subject.format(
+          expect(subject.format(
               'there are %{horses_count:horses}',
               :horses_count => 3, :horses => { :other => '%{horses_count}, seriously %{horses_count}, horses' }
-          ).should == 'there are 3, seriously 3, horses'
+          )).to eq('there are 3, seriously 3, horses')
         end
 
         it 'throws an exception if pluralization patterns is not a hash' do
-          lambda do
+          expect do
             subject.format('there %{horses_count:horses}', :horses_count => 1, :horses => [])
-          end.should raise_error(ArgumentError, 'expected patterns to be a Hash')
+          end.to raise_error(ArgumentError, 'expected patterns to be a Hash')
         end
       end
 
       context 'with inline pluralization' do
         it 'pluralizes with a simple replacement' do
-          subject.format("there #{horses_string}", :horses_count => 1).should == 'there is 1 horse'
+          expect(subject.format("there #{horses_string}", :horses_count => 1)).to eq('there is 1 horse')
         end
 
         it 'pluralizes when there are named interpolation patterns in the string' do
-          subject.format("%{there} #{horses_string}", :horses_count => 1).should == '%{there} is 1 horse'
+          expect(subject.format("%{there} #{horses_string}", :horses_count => 1)).to eq('%{there} is 1 horse')
         end
 
         it 'supports multiple patterns sets for the same number' do
-          subject.format(
+          expect(subject.format(
               %Q(there %<{ "horses_count": {"one": "is", "other": "are"} }> #{simple_horses_string}), :horses_count => 1
-          ).should == 'there is 1 horse'
+          )).to eq('there is 1 horse')
         end
 
         it 'pluralizes multiple entries' do
-          subject.format(
+          expect(subject.format(
               %Q(there %<{ "yaks_count": {"one": "is 1 yak", "other": "are %{yaks_count} yaks"} }> and #{simple_horses_string}),
               :yaks_count => 1, :horses_count => 2
-          ).should == 'there is 1 yak and 2 horses'
+          )).to eq('there is 1 yak and 2 horses')
         end
 
         it 'substitutes the number for a placeholder in the pattern' do
-          subject.format(
+          expect(subject.format(
               "there #{horses_string}", :horses_count => 3, :horses => horses
-          ).should == 'there are 3 horses'
+          )).to eq('there are 3 horses')
         end
 
         it 'substitutes the number for multiple placeholders in the pattern' do
-          subject.format(
+          expect(subject.format(
               'there are %<{ "horses_count": {"other": "%{horses_count}, seriously %{horses_count}, horses"} }>',
               :horses_count => 3
-          ).should == 'there are 3, seriously 3, horses'
+          )).to eq('there are 3, seriously 3, horses')
         end
 
         it 'throws an exception if pluralization hash has more than one key' do
-          lambda do
+          expect do
             subject.format('there are %<{ "horses_count": {}, "foo": {} }>', {})
-          end.should raise_error(ArgumentError, 'expected a Hash with a single key')
+          end.to raise_error(ArgumentError, 'expected a Hash with a single key')
         end
       end
 
       context 'with mixed pluralization' do
         it 'pluralizes separate groups' do
-          subject.format(
+          expect(subject.format(
               "there %{yaks_count:yaks} and #{simple_horses_string}",
               :yaks => yaks, :yaks_count => 3, :horses_count => 2
-          ).should == 'there are 3 yaks and 2 horses'
+          )).to eq('there are 3 yaks and 2 horses')
         end
 
         it 'pluralizes similar groups' do
-          subject.format(
+          expect(subject.format(
               "there %{horses_count:horses} + #{simple_horses_string}",
               :horses => horses, :horses_count => 2
-          ).should == 'there are 2 horses + 2 horses'
+          )).to eq('there are 2 horses + 2 horses')
         end
       end
     end
@@ -198,7 +198,7 @@ describe PluralFormatter do
   describe '#pluralization_rule' do
     it 'delegates pluralization rule fetching to Rules.rule_for method' do
       mock(Plurals::Rules).rule_for(42, :jp) { 'result' }
-      PluralFormatter.new(:jp).send(:pluralization_rule, 42).should == 'result'
+      expect(PluralFormatter.new(:jp).send(:pluralization_rule, 42)).to eq('result')
     end
   end
 

data/spec/formatters/plurals/rules_spec.rb

@@ -12,17 +12,17 @@ describe Rules do
     it "calls eval on the hash that gets returned, lambdas and all" do
       result = Rules.send(:get_resource, :ru)
 
-      result.should include(:keys, :rule)
-      result[:keys].size.should == 3
-      result[:rule].should be_a(Proc)
+      expect(result).to include(:keys, :rule)
+      expect(result[:keys].size).to eq(3)
+      expect(result[:rule]).to be_a(Proc)
     end
   end
 
   describe "#rule_for" do
     it "returns :one for English 1, :other for everything else" do
-      Rules.rule_for(1, :en).should == :one
+      expect(Rules.rule_for(1, :en)).to eq(:one)
       [5, 9, 10, 20, 60, 99, 100, 103, 141].each do |num|
-        Rules.rule_for(num, :en).should == :other
+        expect(Rules.rule_for(num, :en)).to eq(:other)
       end
     end
 
@@ -34,34 +34,34 @@ describe Rules do
       }
 
       rules.each do |rule, examples|
-        examples.each { |n| Rules.rule_for(n, :ru).should == rule }
+        examples.each { |n| expect(Rules.rule_for(n, :ru)).to eq(rule) }
       end
     end
 
     it "returns :other if there's an error" do
       stub(Rules).get_resource { lambda { raise "Jelly beans" } }
-      Rules.rule_for(1, :en).should == :other
-      Rules.rule_for(1, :ru).should == :other
+      expect(Rules.rule_for(1, :en)).to eq(:other)
+      expect(Rules.rule_for(1, :ru)).to eq(:other)
     end
   end
 
   describe "#all_for" do
     it "returns a list of all applicable rules for the given locale" do
-      Rules.all_for(:en).should =~ [:one, :other]
-      Rules.all_for(:ru).should =~ [:one, :many, :other]
+      expect(Rules.all_for(:en)).to match_array([:one, :other])
+      expect(Rules.all_for(:ru)).to match_array([:one, :many, :other])
     end
 
     it "returns nil on error" do
       stub(Rules).get_resource { lambda { raise "Jelly beans" } }
-      Rules.all_for(:en).should be_nil
-      Rules.all_for(:ru).should be_nil
+      expect(Rules.all_for(:en)).to be_nil
+      expect(Rules.all_for(:ru)).to be_nil
     end
   end
 
   describe "#all" do
     it "gets rules for the default locale (usually supplied by FastGettext)" do
       mock(TwitterCldr).locale { :ru }
-      Rules.all.should =~ [:one, :many, :other]
+      expect(Rules.all).to match_array([:one, :many, :other])
     end
   end
 end

data/spec/localized/localized_array_spec.rb

@@ -10,7 +10,7 @@ include TwitterCldr::Localized
 describe LocalizedArray do
   describe '#code_points_to_string' do
     it 'transforms an array of code points into a string' do
-      [0x74, 0x77, 0x69, 0x74, 0x74, 0x65, 0x72].localize.code_points_to_string.should == 'twitter'
+      expect([0x74, 0x77, 0x69, 0x74, 0x74, 0x65, 0x72].localize.code_points_to_string).to eq('twitter')
     end
   end
 
@@ -24,25 +24,25 @@ describe LocalizedArray do
 
     describe '#sort' do
       it 'returns a new LocalizedArray' do
-        localized.sort.should be_instance_of(LocalizedArray)
+        expect(localized.sort).to be_instance_of(LocalizedArray)
       end
 
       it 'does not change the original array' do
-        lambda { localized.sort }.should_not change { localized.base_obj }
+        expect { localized.sort }.not_to change { localized.base_obj }
       end
 
       it 'sorts strings in the array with corresponding collator' do
-        localized.sort.base_obj.should == sorted
+        expect(localized.sort.base_obj).to eq(sorted)
       end
     end
 
     describe '#sort!' do
       it 'returns self' do
-        localized.sort!.object_id.should == localized.object_id
+        expect(localized.sort!.object_id).to eq(localized.object_id)
       end
 
       it 'sorts the array in-place' do
-        localized.sort!.base_obj.should == sorted
+        expect(localized.sort!.base_obj).to eq(sorted)
       end
     end
   end
@@ -53,14 +53,14 @@ describe LocalizedArray do
       index = 0
 
       arr.localize.each do |item|
-        arr[index].should == item
+        expect(arr[index]).to eq(item)
         index += 1
       end
     end
 
     it "should support a few of the other methods in Enumerable" do
-      [1, 2, 3].localize.inject(0) { |sum, num| sum += num; sum }.should == 6
-      [1, 2, 3].localize.map { |item| item + 1 }.should == [2, 3, 4]
+      expect([1, 2, 3].localize.inject(0) { |sum, num| sum += num; sum }).to eq(6)
+      expect([1, 2, 3].localize.map { |item| item + 1 }).to eq([2, 3, 4])
     end
   end
 
@@ -69,9 +69,9 @@ describe LocalizedArray do
       arr = [:foo, "bar", Object.new]
       result = YAML.load(arr.localize.to_yaml)
 
-      result[0].should == :foo
-      result[1].should == "bar"
-      result[2].should be_a(Object)
+      expect(result[0]).to eq(:foo)
+      expect(result[1]).to eq("bar")
+      expect(result[2]).to be_a(Object)
     end
   end
 end

data/spec/localized/localized_date_spec.rb

@@ -18,45 +18,45 @@ describe LocalizedDate do
     it "should ago-ify from now when no base_time given" do
       stub(Time).now { Time.gm(2010, 8, 6, 12, 12, 30) }
       loc_date = date_time.localize(:ko).to_date
-      loc_date.ago.to_s(:unit => :hour).should match_normalized("744시간 전")
+      expect(loc_date.ago.to_s(:unit => :hour)).to match_normalized("744시간 전")
     end
 
     it "should ago-ify with appropriate unit when no unit given" do
       loc_date = date_time.localize(:en).to_date
-      loc_date.ago(:base_time => base_time).to_s.should match_normalized("1 month ago")
-      loc_date.ago(:base_time => Time.gm(2010, 12, 6, 12, 12, 30)).to_s.should match_normalized("5 months ago")
-      loc_date.ago(:base_time => Time.gm(2010, 7, 7, 12, 12, 30)).to_s.should match_normalized("1 day ago")
+      expect(loc_date.ago(:base_time => base_time).to_s).to match_normalized("1 month ago")
+      expect(loc_date.ago(:base_time => Time.gm(2010, 12, 6, 12, 12, 30)).to_s).to match_normalized("5 months ago")
+      expect(loc_date.ago(:base_time => Time.gm(2010, 7, 7, 12, 12, 30)).to_s).to match_normalized("1 day ago")
     end
 
     it "should ago-ify with strings regardless of variable's placement or existence" do
       loc_date = date_time.localize(:ar).to_date
-      loc_date.ago(:base_time => base_time).to_s(:unit => :hour).should match_normalized("قبل 744 ساعة")
-      loc_date.ago(:base_time => base_time).to_s(:unit => :day).should match_normalized("قبل 31 يومًا")
-      loc_date.ago(:base_time => base_time).to_s(:unit => :month).should match_normalized("قبل 1 من الشهور")
-      loc_date.ago(:base_time => base_time).to_s(:unit => :year).should match_normalized("قبل 0 من السنوات")
+      expect(loc_date.ago(:base_time => base_time).to_s(:unit => :hour)).to match_normalized("قبل 744 ساعة")
+      expect(loc_date.ago(:base_time => base_time).to_s(:unit => :day)).to match_normalized("قبل 31 يومًا")
+      expect(loc_date.ago(:base_time => base_time).to_s(:unit => :month)).to match_normalized("قبل 1 من الشهور")
+      expect(loc_date.ago(:base_time => base_time).to_s(:unit => :year)).to match_normalized("قبل 0 من السنوات")
 
       loc_date = date_time.localize(:fa).to_date
-      loc_date.ago(:base_time => base_time).to_s(:unit => :day).should match_normalized("31 روز پیش")
+      expect(loc_date.ago(:base_time => base_time).to_s(:unit => :day)).to match_normalized("31 روز پیش")
 
       loc_date = date_time.localize(:en).to_date
-      loc_date.ago(:base_time => base_time).to_s(:unit => :day).should match_normalized("31 days ago")
+      expect(loc_date.ago(:base_time => base_time).to_s(:unit => :day)).to match_normalized("31 days ago")
     end
 
     it "should ago-ify a date with a number of different units" do
       date_time = DateTime.new(2010, 6, 6, 12, 12, 30)
       loc_date = date_time.localize(:de).to_date
-      loc_date.ago(:base_time => base_time).to_s(:unit => :second).should match_normalized("Vor 5270400 Sekunden")
-      loc_date.ago(:base_time => base_time).to_s(:unit => :minute).should match_normalized("Vor 87840 Minuten")
-      loc_date.ago(:base_time => base_time).to_s(:unit => :hour).should match_normalized("Vor 1464 Stunden")
-      loc_date.ago(:base_time => base_time).to_s(:unit => :day).should match_normalized("Vor 61 Tagen")
-      loc_date.ago(:base_time => base_time).to_s(:unit => :month).should match_normalized("Vor 2 Monaten")
-      loc_date.ago(:base_time => base_time).to_s(:unit => :year).should match_normalized("Vor 0 Jahren")
+      expect(loc_date.ago(:base_time => base_time).to_s(:unit => :second)).to match_normalized("Vor 5270400 Sekunden")
+      expect(loc_date.ago(:base_time => base_time).to_s(:unit => :minute)).to match_normalized("Vor 87840 Minuten")
+      expect(loc_date.ago(:base_time => base_time).to_s(:unit => :hour)).to match_normalized("Vor 1464 Stunden")
+      expect(loc_date.ago(:base_time => base_time).to_s(:unit => :day)).to match_normalized("Vor 61 Tagen")
+      expect(loc_date.ago(:base_time => base_time).to_s(:unit => :month)).to match_normalized("Vor 2 Monaten")
+      expect(loc_date.ago(:base_time => base_time).to_s(:unit => :year)).to match_normalized("Vor 0 Jahren")
     end
 
     it "should return an error if called on a date in the future" do
       date_time = DateTime.new(2010, 10, 10, 12, 12, 30)
       loc_date = date_time.localize(:de).to_date
-      lambda { loc_date.ago(base_time, :second)}.should raise_error(ArgumentError)
+      expect { loc_date.ago(base_time, :second)}.to raise_error(ArgumentError)
     end
   end
 
@@ -66,18 +66,18 @@ describe LocalizedDate do
     it "should until-ify with a number of different units" do
       date_time = DateTime.new(2010, 10, 10, 12, 12, 30)
       loc_date = date_time.localize(:de).to_date
-      loc_date.until(:base_time => base_time).to_s(:unit => :second).should match_normalized("In 5616000 Sekunden")
-      loc_date.until(:base_time => base_time).to_s(:unit => :minute).should match_normalized("In 93600 Minuten")
-      loc_date.until(:base_time => base_time).to_s(:unit => :hour).should match_normalized("In 1560 Stunden")
-      loc_date.until(:base_time => base_time).to_s(:unit => :day).should match_normalized("In 65 Tagen")
-      loc_date.until(:base_time => base_time).to_s(:unit => :month).should match_normalized("In 2 Monaten")
-      loc_date.until(:base_time => base_time).to_s(:unit => :year).should match_normalized("In 0 Jahren")
+      expect(loc_date.until(:base_time => base_time).to_s(:unit => :second)).to match_normalized("In 5616000 Sekunden")
+      expect(loc_date.until(:base_time => base_time).to_s(:unit => :minute)).to match_normalized("In 93600 Minuten")
+      expect(loc_date.until(:base_time => base_time).to_s(:unit => :hour)).to match_normalized("In 1560 Stunden")
+      expect(loc_date.until(:base_time => base_time).to_s(:unit => :day)).to match_normalized("In 65 Tagen")
+      expect(loc_date.until(:base_time => base_time).to_s(:unit => :month)).to match_normalized("In 2 Monaten")
+      expect(loc_date.until(:base_time => base_time).to_s(:unit => :year)).to match_normalized("In 0 Jahren")
     end
 
     it "should return an error if called on a date in the past" do
       date_time = DateTime.new(2010, 4, 4, 12, 12, 30)
       loc_date = date_time.localize(:de).to_date
-      lambda { loc_date.until(base_time, :second)}.should raise_error(ArgumentError)
+      expect { loc_date.until(base_time, :second)}.to raise_error(ArgumentError)
     end
   end
 
@@ -91,7 +91,7 @@ describe LocalizedDate 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)'
       )
 
@@ -107,16 +107,16 @@ describe LocalizedDate do
       date_time = DateTime.new(1987, 9, 20, 0, 0, 0)
       time = Time.local(2000, 5, 12, 22, 5)
       datetime = date_time.localize.to_date.to_datetime(time)
-      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 LocalizedTime too" do
       date_time = DateTime.new(1987, 9, 20, 0, 0, 0)
       time = Time.local(2000, 5, 12, 22, 5).localize
       datetime = date_time.localize.to_date.to_datetime(time)
-      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
 
@@ -124,7 +124,7 @@ describe LocalizedDate do
     it "don't raise errors for any locale" do
       TwitterCldr.supported_locales.each do |locale|
         (LocalizedDate.types - [:additional]).each do |type|
-          lambda { DateTime.now.localize(locale).to_date.send(:"to_#{type}_s") }.should_not raise_error
+          expect { DateTime.now.localize(locale).to_date.send(:"to_#{type}_s") }.not_to raise_error
         end
       end
     end
@@ -133,9 +133,9 @@ describe LocalizedDate do
   describe "#with_timezone" do
     it "calculates the right day depending on the timezone" do
       loc_date = DateTime.new(1987, 9, 20, 0, 0, 0).localize.to_date
-      loc_date.to_s.should == "Sep 20, 1987"
-      loc_date.with_timezone("America/Los_Angeles").to_s.should == "Sep 19, 1987"
-      loc_date.with_timezone("Asia/Tokyo").to_s.should == "Sep 20, 1987"
+      expect(loc_date.to_s).to eq("Sep 20, 1987")
+      expect(loc_date.with_timezone("America/Los_Angeles").to_s).to eq("Sep 19, 1987")
+      expect(loc_date.with_timezone("Asia/Tokyo").to_s).to eq("Sep 20, 1987")
     end
   end
 

data/spec/localized/localized_datetime_spec.rb

@@ -13,11 +13,11 @@ describe LocalizedDateTime do
 
   describe '#initilize' do
     it 'sets calendar type' do
-      date_time.localize(:th, :calendar_type => :buddhist).calendar_type.should == :buddhist
+      expect(date_time.localize(:th, :calendar_type => :buddhist).calendar_type).to eq(:buddhist)
     end
 
     it 'uses default calendar type' do
-      date_time.localize(:en).calendar_type.should == TwitterCldr::DEFAULT_CALENDAR_TYPE
+      expect(date_time.localize(:en).calendar_type).to eq(TwitterCldr::DEFAULT_CALENDAR_TYPE)
     end
   end
 
@@ -31,7 +31,7 @@ describe LocalizedDateTime 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)'
       )
 
@@ -44,7 +44,7 @@ describe LocalizedDateTime do
 
   describe "#to_date" do
     it "should convert to a date" do
-      date_time.localize.to_date.base_obj.strftime("%Y-%m-%d").should == "1987-09-20"
+      expect(date_time.localize.to_date.base_obj.strftime("%Y-%m-%d")).to eq("1987-09-20")
     end
 
     it 'forwards calendar type' do
@@ -54,7 +54,7 @@ describe LocalizedDateTime do
 
   describe "#to_time" do
     it "should convert to a time" do
-      date_time.localize.to_time.base_obj.getgm.strftime("%H:%M:%S").should == "22:05:00"
+      expect(date_time.localize.to_time.base_obj.getgm.strftime("%H:%M:%S")).to eq("22:05:00")
     end
 
     it 'forwards calendar type' do
@@ -64,7 +64,7 @@ describe LocalizedDateTime do
 
   describe "#to_timespan" do
     it "should return a localized timespan" do
-      date_time.localize.to_timespan.should be_a(LocalizedTimespan)
+      expect(date_time.localize.to_timespan).to be_a(LocalizedTimespan)
     end
   end
 
@@ -72,7 +72,7 @@ describe LocalizedDateTime do
     it "don't raise errors for any locale" do
       TwitterCldr.supported_locales.each do |locale|
         (TwitterCldr::DataReaders::CalendarDataReader.types - [:additional]).each do |type|
-          lambda { date_time.localize(locale).send(:"to_#{type}_s") }.should_not raise_error
+          expect { date_time.localize(locale).send(:"to_#{type}_s") }.not_to raise_error
         end
       end
     end
@@ -93,16 +93,16 @@ describe LocalizedDateTime do
     it "uses the default format if no :format is given" do
       loc_date = date_time.localize
       mock.proxy(loc_date).to_default_s
-      loc_date.to_s.should == "Sep 20, 1987, 10:05:00 PM"
+      expect(loc_date.to_s).to eq("Sep 20, 1987, 10:05:00 PM")
     end
   end
 
   describe "#with_timezone" do
     it "calculates the right time depending on the timezone" do
       loc_date = date_time.localize
-      loc_date.to_s.should == "Sep 20, 1987, 10:05:00 PM"
-      loc_date.with_timezone("America/Los_Angeles").to_s.should == "Sep 20, 1987, 3:05:00 PM"
-      loc_date.with_timezone("America/New_York").to_s.should == "Sep 20, 1987, 6:05:00 PM"
+      expect(loc_date.to_s).to eq("Sep 20, 1987, 10:05:00 PM")
+      expect(loc_date.with_timezone("America/Los_Angeles").to_s).to eq("Sep 20, 1987, 3:05:00 PM")
+      expect(loc_date.with_timezone("America/New_York").to_s).to eq("Sep 20, 1987, 6:05:00 PM")
     end
   end
 

data/spec/localized/localized_hash_spec.rb

@@ -13,10 +13,10 @@ describe LocalizedHash do
       hash = { :foo => "bar", "string_key" => Object.new }
       result = YAML.load(hash.localize.to_yaml)
 
-      result.should include(:foo)
-      result.should include("string_key")
-      result[:foo].should == "bar"
-      result["string_key"].should be_a(Object)
+      expect(result).to include(:foo)
+      expect(result).to include("string_key")
+      expect(result[:foo]).to eq("bar")
+      expect(result["string_key"]).to be_a(Object)
     end
   end
 end