twitter_cldr 3.0.1 → 3.0.2

data/spec/shared/casefolder_spec.rb

@@ -10,13 +10,13 @@ include TwitterCldr::Shared
 describe Casefolder do
   describe "#casefold" do
     it "should casefold a few canonical examples" do
-      Casefolder.casefold("Weißrussland").should == "weissrussland"
-      Casefolder.casefold("Hello, World").should == "hello, world"
+      expect(Casefolder.casefold("Weißrussland")).to eq("weissrussland")
+      expect(Casefolder.casefold("Hello, World")).to eq("hello, world")
     end
 
     it "should correctly casefold the Turkic i character" do
-      Casefolder.casefold("Istanbul", true).should == "ıstanbul"
-      Casefolder.casefold("İstanbul", true).should == "istanbul"
+      expect(Casefolder.casefold("Istanbul", true)).to eq("ıstanbul")
+      expect(Casefolder.casefold("İstanbul", true)).to eq("istanbul")
     end
 
     # the files used in this test come from the unicode_utils gem
@@ -24,7 +24,7 @@ describe Casefolder do
       base_path = File.dirname(__FILE__)
       text = File.read(File.join(base_path, "casefolding.txt"))
       expected = File.read(File.join(base_path, "casefolding_expected.txt"))
-      Casefolder.casefold(text).should == expected
+      expect(Casefolder.casefold(text)).to eq(expected)
     end
   end
 end

data/spec/shared/code_point_spec.rb

@@ -26,15 +26,15 @@ describe CodePoint do
       let(:decomposition) { '0028 007A 0029' }
 
       it 'parses decomposition mapping' do
-        code_point.decomposition.should == [0x28, 0x7A, 0x29]
+        expect(code_point.decomposition).to eq([0x28, 0x7A, 0x29])
       end
 
       it 'initializes compatibility tag as nil' do
-        code_point.compatibility_decomposition_tag.should be_nil
+        expect(code_point.compatibility_decomposition_tag).to be_nil
       end
 
       it 'returns false from compatibility_decomposition?' do
-        code_point.should_not be_compatibility_decomposition
+        expect(code_point).not_to be_compatibility_decomposition
       end
     end
 
@@ -42,15 +42,15 @@ describe CodePoint do
       let(:decomposition) { '<font> 0028 007A 0029' }
 
       it 'parses decomposition mapping' do
-        code_point.decomposition.should == [0x28, 0x7A, 0x29]
+        expect(code_point.decomposition).to eq([0x28, 0x7A, 0x29])
       end
 
       it 'initializes compatibility decomposition tag' do
-        code_point.compatibility_decomposition_tag.should == 'font'
+        expect(code_point.compatibility_decomposition_tag).to eq('font')
       end
 
       it 'returns true from compatibility_decomposition?' do
-        code_point.should be_compatibility_decomposition
+        expect(code_point).to be_compatibility_decomposition
       end
     end
 
@@ -58,15 +58,15 @@ describe CodePoint do
       let(:decomposition) { '' }
 
       it 'parses decomposition mapping' do
-        code_point.decomposition.should be_nil
+        expect(code_point.decomposition).to be_nil
       end
 
       it 'initializes compatibility tag as nil' do
-        code_point.compatibility_decomposition_tag.should be_nil
+        expect(code_point.compatibility_decomposition_tag).to be_nil
       end
 
       it 'returns false from compatibility_decomposition?' do
-        code_point.should_not be_compatibility_decomposition
+        expect(code_point).not_to be_compatibility_decomposition
       end
     end
   end
@@ -74,12 +74,12 @@ describe CodePoint do
   describe "#find" do
     it "retrieves information for any valid code point" do
       data = CodePoint.find(0x301)
-      data.should be_a(CodePoint)
-      data.fields.length.should == 15
+      expect(data).to be_a(CodePoint)
+      expect(data.fields.length).to eq(15)
     end
 
     it "returns nil if the information is not found" do
-      CodePoint.find(0xFFFFFFF).should be_nil
+      expect(CodePoint.find(0xFFFFFFF)).to be_nil
     end
 
     it "fetches valid information for the specified code point" do
@@ -106,9 +106,9 @@ describe CodePoint do
       test_data.each do |code_point, data|
         cp_data = CodePoint.find(code_point)
 
-        cp_data.should_not be_nil
+        expect(cp_data).not_to be_nil
 
-        [:code_point, :name, :category, :combining_class].map { |msg| cp_data.send(msg) }.should == data[0..3]
+        expect([:code_point, :name, :category, :combining_class].map { |msg| cp_data.send(msg) }).to eq(data[0..3])
       end
     end
   end
@@ -116,32 +116,32 @@ describe CodePoint do
   describe "#code_points_for{index}" do
     it "returns code points for the given general unicode property name" do
       cps = CodePoint.code_points_for_category(:Cc)
-      cps.should be_a(Array)
-      cps.first.should == (0..31)
+      expect(cps).to be_a(Array)
+      expect(cps.first).to eq(0..31)
 
       cps = CodePoint.code_points_for_bidi_class(:BN)
-      cps.should be_a(Array)
-      cps.first.should == (0..8)
+      expect(cps).to be_a(Array)
+      expect(cps.first).to eq(0..8)
 
       cps = CodePoint.code_points_for_bidi_mirrored(:N)
-      cps.should be_a(Array)
-      cps.first.should == (0..39)
+      expect(cps).to be_a(Array)
+      expect(cps.first).to eq(0..39)
     end
   end
 
   describe "#code_points_for_property_value" do
     it "returns code points for the given unicode property and value" do
       cps = CodePoint.code_points_for_line_break(:CM)
-      cps.should be_a(Array)
-      cps.first.should == (0..8)
+      expect(cps).to be_a(Array)
+      expect(cps.first).to eq(0..8)
 
       cps = CodePoint.code_points_for_sentence_break(:Extend)
-      cps.should be_a(Array)
-      cps.first.should == (768..879)
+      expect(cps).to be_a(Array)
+      expect(cps.first).to eq(768..879)
 
       cps = CodePoint.code_points_for_word_break(:Hebrew_Letter)
-      cps.should be_a(Array)
-      cps.first.should == (1488..1514)
+      expect(cps).to be_a(Array)
+      expect(cps.first).to eq(1488..1514)
     end
   end
 
@@ -158,18 +158,18 @@ describe CodePoint do
       end
 
       it "should return a code point with the correct value" do
-        CodePoint.for_canonical_decomposition([123, 456]).should == "I'm code point 789"
+        expect(CodePoint.for_canonical_decomposition([123, 456])).to eq("I'm code point 789")
       end
 
       it "should return nil if no decomposition mapping exists" do
-        CodePoint.for_canonical_decomposition([987]).should be_nil
+        expect(CodePoint.for_canonical_decomposition([987])).to be_nil
       end
     end
 
     it "should cache the decomposition map" do
       mock(TwitterCldr).get_resource(:unicode_data, :canonical_compositions) { canonical_compositions }.once
-      CodePoint.for_canonical_decomposition([0xA0]).should be_nil
-      CodePoint.for_canonical_decomposition([0xA0]).should be_nil
+      expect(CodePoint.for_canonical_decomposition([0xA0])).to be_nil
+      expect(CodePoint.for_canonical_decomposition([0xA0])).to be_nil
     end
   end
 
@@ -186,29 +186,29 @@ describe CodePoint do
     end
 
     it "returns nil if not part of a hangul block" do
-      CodePoint.hangul_type(100).should == nil
+      expect(CodePoint.hangul_type(100)).to eq(nil)
     end
 
     it "returns the correct part (i.e. lpart, vpart, or tpart) before composition or decomposition" do
-      CodePoint.hangul_type(5).should  == :lparts
-      CodePoint.hangul_type(30).should == :vparts
-      CodePoint.hangul_type(41).should == :tparts
+      expect(CodePoint.hangul_type(5)).to  eq(:lparts)
+      expect(CodePoint.hangul_type(30)).to eq(:vparts)
+      expect(CodePoint.hangul_type(41)).to eq(:tparts)
     end
 
     it "returns composition if no part can be found" do
-      CodePoint.hangul_type(11).should == :compositions
+      expect(CodePoint.hangul_type(11)).to eq(:compositions)
     end
   end
 
   describe "#excluded_from_composition?" do
     it "excludes anything in the list of ranges" do
       stub(CodePoint).composition_exclusions { [10..10, 13..14, 20..30] }
-      CodePoint.excluded_from_composition?(10).should be_true
-      CodePoint.excluded_from_composition?(13).should be_true
-      CodePoint.excluded_from_composition?(14).should be_true
-      CodePoint.excluded_from_composition?(15).should be_false
-      CodePoint.excluded_from_composition?(19).should be_false
-      CodePoint.excluded_from_composition?(100).should be_false
+      expect(CodePoint.excluded_from_composition?(10)).to be_true
+      expect(CodePoint.excluded_from_composition?(13)).to be_true
+      expect(CodePoint.excluded_from_composition?(14)).to be_true
+      expect(CodePoint.excluded_from_composition?(15)).to be_false
+      expect(CodePoint.excluded_from_composition?(19)).to be_false
+      expect(CodePoint.excluded_from_composition?(100)).to be_false
     end
   end
 
@@ -219,21 +219,21 @@ describe CodePoint do
 
     it "finds the block that corresponds to the code point" do
       stub(TwitterCldr).get_resource(:unicode_data, :blocks) { [[:klingon, 122..307], [:hirogen, 1337..2200]] }
-      CodePoint.send(:get_block, 200).should  == [:klingon, 122..307]
-      CodePoint.send(:get_block, 2199).should == [:hirogen, 1337..2200]
-      CodePoint.send(:get_block, 100).should be_nil
+      expect(CodePoint.send(:get_block, 200)).to  eq([:klingon, 122..307])
+      expect(CodePoint.send(:get_block, 2199)).to eq([:hirogen, 1337..2200])
+      expect(CodePoint.send(:get_block, 100)).to be_nil
     end
   end
 
   describe "#get_range_start" do
     it "returns the data for a non-explicit range" do
       block_data = { 0x1337 => [0x1337, "<CJK Ideograph Extension A, First>"] }
-      CodePoint.send(:get_range_start, 0xABC, block_data).should == [0xABC, "<CJK Ideograph Extension A>"]
+      expect(CodePoint.send(:get_range_start, 0xABC, block_data)).to eq([0xABC, "<CJK Ideograph Extension A>"])
     end
 
     it "returns nil if the block data doesn't contain a non-explicit range" do
       block_data = { 0x1337 => [0x1337, "<CJK Ideograph Extension A>"] }
-      CodePoint.send(:get_range_start, 0xABC, block_data).should == nil
+      expect(CodePoint.send(:get_range_start, 0xABC, block_data)).to eq(nil)
     end
   end
 end

data/spec/shared/currencies_spec.rb

@@ -15,16 +15,16 @@ describe Currencies do
     it "should list all supported country codes" do
       codes = Currencies.currency_codes
 
-      codes.size.should == 297
-      codes.should include(*TEST_CODES)
+      expect(codes.size).to eq(297)
+      expect(codes).to include(*TEST_CODES)
     end
   end
 
   describe "#for_code" do
     it "should return all information for PEN" do
       data = Currencies.for_code("PEN")
-      data.should be_a(Hash)
-      data.should include(
+      expect(data).to be_a(Hash)
+      expect(data).to include(
         :name        => "Peruvian nuevo sol",
         :currency    => :PEN,
         :symbol      => "S/.",
@@ -34,8 +34,8 @@ describe Currencies do
 
     it "should return all information for CAD, a currency code with multiple possible symbols" do
       data = Currencies.for_code("CAD")
-      data.should be_a(Hash)
-      data.should include(
+      expect(data).to be_a(Hash)
+      expect(data).to include(
         :name        => "Canadian dollar",
         :currency    => :CAD,
         :symbol      => "$",
@@ -46,7 +46,7 @@ describe Currencies do
     it "verifies that all code_points values are equivalent to their corresponding symbols" do
       Currencies.currency_codes.select do |code|
         data = Currencies.for_code(code)
-        data[:code_points].pack("U*").should == data[:symbol]
+        expect(data[:code_points].pack("U*")).to eq(data[:symbol])
       end
     end
   end

data/spec/shared/language_codes_spec.rb

@@ -12,79 +12,79 @@ describe LanguageCodes do
     let(:languages) { LanguageCodes.languages }
 
     it 'returns an array' do
-      languages.should be_instance_of(Array)
+      expect(languages).to be_instance_of(Array)
     end
 
     it 'returns symbols' do
-      languages.each { |language| language.should be_instance_of(Symbol) }
+      languages.each { |language| expect(language).to be_instance_of(Symbol) }
     end
 
     it 'returns supported languages' do
-      languages.should include(:Spanish, :English, :Russian, :Japanese, :Basque)
+      expect(languages).to include(:Spanish, :English, :Russian, :Japanese, :Basque)
     end
   end
 
   describe '#valid_standard?' do
     it 'returns true if the standard is valid' do
-      LanguageCodes.valid_standard?(:iso_639_2).should be_true
+      expect(LanguageCodes.valid_standard?(:iso_639_2)).to be_true
     end
 
     it 'returns false if the standard is invalid' do
-      LanguageCodes.valid_standard?(:iso_639).should be_false
+      expect(LanguageCodes.valid_standard?(:iso_639)).to be_false
     end
 
     it 'accepts a string' do
-      LanguageCodes.valid_standard?('iso_639_2').should be_true
+      expect(LanguageCodes.valid_standard?('iso_639_2')).to be_true
     end
   end
 
   describe '#valid_code?' do
     it 'returns true if the code is present in the given standard' do
-      LanguageCodes.valid_code?(:spa, :iso_639_2).should be_true
+      expect(LanguageCodes.valid_code?(:spa, :iso_639_2)).to be_true
     end
 
     it 'returns false if the code is not present in the given standard' do
-      LanguageCodes.valid_code?(:foo, :iso_639_2).should be_false
+      expect(LanguageCodes.valid_code?(:foo, :iso_639_2)).to be_false
     end
 
     it 'raises exception if the standard is invalid' do
-      lambda { LanguageCodes.valid_code?(:es, :foobar) }.should raise_exception(ArgumentError, ':foobar is not a valid standard name')
+      expect { LanguageCodes.valid_code?(:es, :foobar) }.to raise_exception(ArgumentError, ':foobar is not a valid standard name')
     end
 
     it 'accepts strings' do
-      LanguageCodes.valid_code?('spa', 'iso_639_2').should be_true
+      expect(LanguageCodes.valid_code?('spa', 'iso_639_2')).to be_true
     end
   end
 
   describe '#convert' do
     it 'converts codes between different standards' do
-      LanguageCodes.convert(:Spanish, :from => :name,      :to => :bcp_47   ).should == :es
-      LanguageCodes.convert(:es,      :from => :bcp_47,    :to => :iso_639_1).should == :es
-      LanguageCodes.convert(:es,      :from => :iso_639_1, :to => :iso_639_2).should == :spa
-      LanguageCodes.convert(:spa,     :from => :iso_639_2, :to => :iso_639_3).should == :spa
-      LanguageCodes.convert(:spa,     :from => :iso_639_3, :to => :name     ).should == :Spanish
+      expect(LanguageCodes.convert(:Spanish, :from => :name,      :to => :bcp_47   )).to eq(:es)
+      expect(LanguageCodes.convert(:es,      :from => :bcp_47,    :to => :iso_639_1)).to eq(:es)
+      expect(LanguageCodes.convert(:es,      :from => :iso_639_1, :to => :iso_639_2)).to eq(:spa)
+      expect(LanguageCodes.convert(:spa,     :from => :iso_639_2, :to => :iso_639_3)).to eq(:spa)
+      expect(LanguageCodes.convert(:spa,     :from => :iso_639_3, :to => :name     )).to eq(:Spanish)
     end
 
     it 'converts from terminology iso_639_2 codes' do
-      LanguageCodes.convert(:hye, :from => :iso_639_2, :to => :bcp_47).should == :hy
+      expect(LanguageCodes.convert(:hye, :from => :iso_639_2, :to => :bcp_47)).to eq(:hy)
     end
 
     it 'converts from alternative bcp_47 codes' do
-      LanguageCodes.convert('ar-adf', :from => :bcp_47, :to => :iso_639_3).should == :adf
+      expect(LanguageCodes.convert('ar-adf', :from => :bcp_47, :to => :iso_639_3)).to eq(:adf)
     end
 
     it 'returns nil if conversion data is missing' do
-      LanguageCodes.convert(:bsq, :from => :bcp_47, :to => :iso_639_1).should be_nil
-      LanguageCodes.convert(:FooBar, :from => :name, :to => :iso_639_1).should be_nil
+      expect(LanguageCodes.convert(:bsq, :from => :bcp_47, :to => :iso_639_1)).to be_nil
+      expect(LanguageCodes.convert(:FooBar, :from => :name, :to => :iso_639_1)).to be_nil
     end
 
     it 'accepts strings' do
-      LanguageCodes.convert('Spanish', 'from' => 'name', 'to' => 'bcp_47').should == :es
+      expect(LanguageCodes.convert('Spanish', 'from' => 'name', 'to' => 'bcp_47')).to eq(:es)
     end
 
     it 'raises exception if :from or :to options are missing' do
       [[:es, { :to => :bcp_47 }], [:es, { :from => :bcp_47 }], [:es]].each do |args|
-        lambda { LanguageCodes.convert(*args) }.should raise_exception(ArgumentError, "options :from and :to are required")
+        expect { LanguageCodes.convert(*args) }.to raise_exception(ArgumentError, "options :from and :to are required")
       end
     end
 
@@ -94,36 +94,36 @@ describe LanguageCodes do
           [:es, { :from => :bcp_47, :to => :foobar }],
           [:es, { :from => :foobar, :to => :foobar }]
       ].each do |args|
-        lambda { LanguageCodes.convert(*args) }.should raise_exception(ArgumentError, ':foobar is not a valid standard name')
+        expect { LanguageCodes.convert(*args) }.to raise_exception(ArgumentError, ':foobar is not a valid standard name')
       end
     end
   end
 
   describe '#from_language' do
     it 'returns language code by language name' do
-      LanguageCodes.from_language(:Spanish, :iso_639_2).should == :spa
+      expect(LanguageCodes.from_language(:Spanish, :iso_639_2)).to eq(:spa)
     end
 
     it 'accepts strings' do
-      LanguageCodes.from_language('Spanish', 'iso_639_2').should == :spa
+      expect(LanguageCodes.from_language('Spanish', 'iso_639_2')).to eq(:spa)
     end
 
     it 'raises exception when standard is invalid' do
-      lambda { LanguageCodes.from_language(:Spanish, :foobar) }.should raise_exception(':foobar is not a valid standard name')
+      expect { LanguageCodes.from_language(:Spanish, :foobar) }.to raise_exception(':foobar is not a valid standard name')
     end
   end
 
   describe '#to_language' do
     it 'returns language name as a string by language code' do
-      LanguageCodes.to_language(:es, :iso_639_1).should == 'Spanish'
+      expect(LanguageCodes.to_language(:es, :iso_639_1)).to eq('Spanish')
     end
 
     it 'accepts strings' do
-      LanguageCodes.to_language('es', 'iso_639_1').should == 'Spanish'
+      expect(LanguageCodes.to_language('es', 'iso_639_1')).to eq('Spanish')
     end
 
     it 'raises exception when standard is invalid' do
-      lambda { LanguageCodes.to_language(:es, :foobar) }.should raise_exception(':foobar is not a valid standard name')
+      expect { LanguageCodes.to_language(:es, :foobar) }.to raise_exception(':foobar is not a valid standard name')
     end
   end
 
@@ -131,15 +131,15 @@ describe LanguageCodes do
     let(:spanish_standards) { [:bcp_47, :iso_639_1, :iso_639_2, :iso_639_3] }
 
     it 'returns an array of standards that are available for conversion from a given code' do
-      LanguageCodes.standards_for(:es, :bcp_47).should =~ spanish_standards
+      expect(LanguageCodes.standards_for(:es, :bcp_47)).to match_array(spanish_standards)
     end
 
     it 'accepts string' do
-      LanguageCodes.standards_for('es', 'bcp_47').should =~ spanish_standards
+      expect(LanguageCodes.standards_for('es', 'bcp_47')).to match_array(spanish_standards)
     end
 
     it 'raises exception when standard is invalid' do
-      lambda { LanguageCodes.standards_for(:es, :foobar) }.should raise_exception(':foobar is not a valid standard name')
+      expect { LanguageCodes.standards_for(:es, :foobar) }.to raise_exception(':foobar is not a valid standard name')
     end
   end
 
@@ -147,15 +147,15 @@ describe LanguageCodes do
     let(:spanish_standards) { [:bcp_47, :iso_639_1, :iso_639_2, :iso_639_3] }
 
     it 'returns an array of standards that have a code for a given language' do
-      LanguageCodes.standards_for_language(:Spanish).should =~ spanish_standards
+      expect(LanguageCodes.standards_for_language(:Spanish)).to match_array(spanish_standards)
     end
 
     it 'accepts string' do
-      LanguageCodes.standards_for_language('Spanish').should =~ spanish_standards
+      expect(LanguageCodes.standards_for_language('Spanish')).to match_array(spanish_standards)
     end
 
     it 'returns empty array for unknown languages' do
-      LanguageCodes.standards_for_language('FooBar').should == []
+      expect(LanguageCodes.standards_for_language('FooBar')).to eq([])
     end
   end
 end

data/spec/shared/languages_spec.rb

@@ -10,98 +10,98 @@ include TwitterCldr::Shared
 describe Languages do
   describe "#translate_language" do
     it "should translate a language from one locale to another" do
-      Languages.translate_language("Russian", :en, :es).should match_normalized("ruso")
-      Languages.translate_language("ruso", :es, :en).should match_normalized("Russian")
-      Languages.translate_language("Spanish", :en, :es).should match_normalized("español")
-      Languages.translate_language("ruso", :es, :ru).should match_normalized("русский")
+      expect(Languages.translate_language("Russian", :en, :es)).to match_normalized("ruso")
+      expect(Languages.translate_language("ruso", :es, :en)).to match_normalized("Russian")
+      expect(Languages.translate_language("Spanish", :en, :es)).to match_normalized("español")
+      expect(Languages.translate_language("ruso", :es, :ru)).to match_normalized("русский")
     end
 
     it "should be capitalization agnostic" do
-      Languages.translate_language("russian", :en, :es).should match_normalized("ruso")
-      Languages.translate_language("RUSSIAN", :en, :es).should match_normalized("ruso")
+      expect(Languages.translate_language("russian", :en, :es)).to match_normalized("ruso")
+      expect(Languages.translate_language("RUSSIAN", :en, :es)).to match_normalized("ruso")
     end
 
     it "defaults the destination language to English (or whatever the global locale is)" do
-      Languages.translate_language("Ruso", :es).should match_normalized("Russian")
-      Languages.translate_language("русский", :ru).should match_normalized("Russian")
+      expect(Languages.translate_language("Ruso", :es)).to match_normalized("Russian")
+      expect(Languages.translate_language("русский", :ru)).to match_normalized("Russian")
     end
 
     it "defaults source and destination language to English if not given" do
-      Languages.translate_language("Russian").should match_normalized("Russian")
+      expect(Languages.translate_language("Russian")).to match_normalized("Russian")
       TwitterCldr.locale = :es
-      Languages.translate_language("Russian").should match_normalized("ruso")
+      expect(Languages.translate_language("Russian")).to match_normalized("ruso")
     end
 
     it "successfully translates locale codes that are and are not in the CLDR using the locale map" do
-      Languages.translate_language("Russian", :en, :'zh-cn').should match_normalized("俄文")
-      Languages.translate_language("Russian", :en, :'zh').should match_normalized("俄文")
+      expect(Languages.translate_language("Russian", :en, :'zh-cn')).to match_normalized("俄文")
+      expect(Languages.translate_language("Russian", :en, :'zh')).to match_normalized("俄文")
     end
 
     it "should return nil if no translation was found" do
-      Languages.translate_language("Russian", :en, :blarg).should == nil
+      expect(Languages.translate_language("Russian", :en, :blarg)).to eq(nil)
     end
   end
 
   describe "#from_code_for_locale" do
     it "should return the language in the correct locale for the given locale code (i.e. es in English should be Spanish)" do
-      Languages.from_code_for_locale(:es, :en).should match_normalized("Spanish")
-      Languages.from_code_for_locale(:en, :es).should match_normalized("inglés")
+      expect(Languages.from_code_for_locale(:es, :en)).to match_normalized("Spanish")
+      expect(Languages.from_code_for_locale(:en, :es)).to match_normalized("inglés")
     end
   end
 
   describe "#from_code" do
     it "should return the language in the default locale for the given locale code" do
-      Languages.from_code(:es).should match_normalized("Spanish")
-      Languages.from_code(:ru).should match_normalized("Russian")
+      expect(Languages.from_code(:es)).to match_normalized("Spanish")
+      expect(Languages.from_code(:ru)).to match_normalized("Russian")
       TwitterCldr.locale = :es
-      Languages.from_code(:es).should match_normalized("español")
+      expect(Languages.from_code(:es)).to match_normalized("español")
     end
   end
 
   describe "#all_for" do
     it "should return a hash of all languages for the given language code" do
       langs = Languages.all_for(:es)
-      langs.should be_a(Hash)
-      langs[:ru].should match_normalized("ruso")
+      expect(langs).to be_a(Hash)
+      expect(langs[:ru]).to match_normalized("ruso")
     end
 
     it "should return an empty hash for an invalid language" do
       langs = Languages.all_for(:blarg)
-      langs.should == {}
+      expect(langs).to eq({})
     end
   end
 
   describe "#all" do
     it "should use the default language to get the language hash" do
       langs = Languages.all
-      langs.should be_a(Hash)
-      langs[:ru].should match_normalized("Russian")
-      langs[:de].should match_normalized("German")
+      expect(langs).to be_a(Hash)
+      expect(langs[:ru]).to match_normalized("Russian")
+      expect(langs[:de]).to match_normalized("German")
 
       TwitterCldr.locale = :es
       langs = Languages.all
-      langs.should be_a(Hash)
-      langs[:ru].should match_normalized("ruso")
-      langs[:de].should match_normalized("alemán")
+      expect(langs).to be_a(Hash)
+      expect(langs[:ru]).to match_normalized("ruso")
+      expect(langs[:de]).to match_normalized("alemán")
     end
   end
 
   describe "#is_rtl?" do
     it "should return true for certain locales" do
       [:ar, :he, :ur, :fa].each do |locale|
-        Languages.is_rtl?(locale).should be_true
+        expect(Languages.is_rtl?(locale)).to be_true
       end
     end
 
     it "should return false for certain locales" do
       [:en, :es, :hu, :ja].each do |locale|
-        Languages.is_rtl?(locale).should be_false
+        expect(Languages.is_rtl?(locale)).to be_false
       end
     end
 
     it "should not raise errors for any locale" do
       TwitterCldr.supported_locales.each do |locale|
-        lambda { Languages.is_rtl?(locale) }.should_not raise_error
+        expect { Languages.is_rtl?(locale) }.not_to raise_error
       end
     end
   end

data/spec/shared/numbering_system_spec.rb

@@ -10,12 +10,12 @@ include TwitterCldr::Shared
 describe NumberingSystem do
   describe "#for_name" do
     it "should return the correct numbering system for the given name" do
-      NumberingSystem.for_name("latn").digits.should == %w(0 1 2 3 4 5 6 7 8 9)
-      NumberingSystem.for_name("arab").digits.should == %w(٠ ١ ٢ ٣ ٤ ٥ ٦ ٧ ٨ ٩)
+      expect(NumberingSystem.for_name("latn").digits).to eq(%w(0 1 2 3 4 5 6 7 8 9))
+      expect(NumberingSystem.for_name("arab").digits).to eq(%w(٠ ١ ٢ ٣ ٤ ٥ ٦ ٧ ٨ ٩))
     end
 
     it "should raise an error if the system is not numeric" do
-      lambda { NumberingSystem.for_name("roman") }.should raise_error(UnsupportedNumberingSystemError)
+      expect { NumberingSystem.for_name("roman") }.to raise_error(UnsupportedNumberingSystemError)
     end
   end
 
@@ -24,8 +24,8 @@ describe NumberingSystem do
       let(:system) { NumberingSystem.for_name("arab") }
 
       it "replaces ascii numeral characters with arabic ones" do
-        system.transliterate(123).should match_normalized("١٢٣")
-        system.transliterate(947).should match_normalized("٩٤٧")
+        expect(system.transliterate(123)).to match_normalized("١٢٣")
+        expect(system.transliterate(947)).to match_normalized("٩٤٧")
       end
     end
 
@@ -33,8 +33,8 @@ describe NumberingSystem do
       let(:system) { NumberingSystem.for_name("hanidec") }
 
       it "replaces ascii numeral characters with Han ones" do
-        system.transliterate(123).should match_normalized("一二三")
-        system.transliterate(947).should match_normalized("九四七")
+        expect(system.transliterate(123)).to match_normalized("一二三")
+        expect(system.transliterate(947)).to match_normalized("九四七")
       end
     end
   end