twitter_cldr 4.3.1 → 4.4.0

data/spec/shared/calendar_spec.rb

@@ -22,7 +22,7 @@ describe Calendar do
 
   describe '#initialize' do
     it 'returns calendar for default locale and type' do
-      stub(TwitterCldr).locale { :fr }
+      allow(TwitterCldr).to receive(:locale).and_return(:fr)
       cal = Calendar.new
 
       expect(cal.locale).to eq(:fr)
@@ -68,12 +68,12 @@ describe Calendar do
 
     context 'when some data is missing' do
       it 'returns nil if some names format is missing' do
-        stub(TwitterCldr).get_locale_resource { { de: { calendars: { gregorian: { months: { :'stand-alone' => {} } } } } } }
+        allow(TwitterCldr).to receive(:get_locale_resource).and_return(de: { calendars: { gregorian: { months: { :'stand-alone' => {} } } } })
         expect(calendar.months(:wide)).to eq(nil)
       end
 
       it 'returns nil if calendars data is missing' do
-        stub(TwitterCldr).get_locale_resource { { de: {} } }
+        allow(TwitterCldr).to receive(:get_locale_resource).and_return(de: {})
         expect(calendar.months(:wide)).to eq(nil)
       end
     end
@@ -128,12 +128,12 @@ describe Calendar do
 
     context 'when some data is missing' do
       it 'returns nil if some names format is missing' do
-        stub(TwitterCldr).get_locale_resource { { de: { calendars: { gregorian: { days: { :'stand-alone' => {} } } } } } }
+        allow(TwitterCldr).to receive(:get_locale_resource).and_return(de: { calendars: { gregorian: { days: { :'stand-alone' => {} } } } })
         expect(calendar.weekdays(:wide)).to eq(nil)
       end
 
       it 'returns nil if calendars data is missing' do
-        stub(TwitterCldr).get_locale_resource { { de: {} } }
+        allow(TwitterCldr).to receive(:get_locale_resource).and_return(de: {})
         expect(calendar.weekdays(:wide)).to eq(nil)
       end
     end

data/spec/shared/code_point_spec.rb

@@ -62,7 +62,7 @@ describe CodePoint do
     it 'identifies all properties belonging to the code point' do
       code_point = CodePoint.get(65)
       properties = code_point.properties
-      expect(properties.alphabetic).to be_true
+      expect(properties.alphabetic).to eq(true)
       expect(properties.script).to eq(Set.new(%w(Latin)))
       expect(properties.general_category).to eq(Set.new(%w(L Lu)))
     end
@@ -80,8 +80,8 @@ describe CodePoint do
       database = Object.new
       property_name = 'foo'
       property_value = 'bar'
-      stub(CodePoint).properties { database }
-      mock(database).code_points_for_property(property_name, property_value)
+      allow(CodePoint).to receive(:properties).and_return(database)
+      expect(database).to receive(:code_points_for_property).with(property_name, property_value)
       CodePoint.code_points_for_property(property_name, property_value)
     end
   end
@@ -90,8 +90,8 @@ describe CodePoint do
     it 'delegates to the properties database' do
       database = Object.new
       code_point = 65
-      stub(CodePoint).properties { database }
-      mock(database).properties_for_code_point(code_point)
+      allow(CodePoint).to receive(:properties).and_return(database)
+      expect(database).to receive(:properties_for_code_point).with(code_point)
       CodePoint.properties_for_code_point(code_point)
     end
   end

data/spec/shared/hyphenator_spec.rb

@@ -35,11 +35,11 @@ describe Hyphenator do
 
   describe '.supported_locale?' do
     it 'returns true if the locale is supported' do
-      expect(described_class.supported_locale?(:en)).to be_true
+      expect(described_class.supported_locale?(:en)).to eq(true)
     end
 
     it "returns false if the locale isn't supported" do
-      expect(described_class.supported_locale?(:ko)).to be_false
+      expect(described_class.supported_locale?(:ko)).to eq(false)
     end
   end
 

data/spec/shared/language_codes_spec.rb

@@ -26,25 +26,25 @@ describe LanguageCodes do
 
   describe '#valid_standard?' do
     it 'returns true if the standard is valid' do
-      expect(LanguageCodes.valid_standard?(:iso_639_2)).to be_true
+      expect(LanguageCodes.valid_standard?(:iso_639_2)).to eq(true)
     end
 
     it 'returns false if the standard is invalid' do
-      expect(LanguageCodes.valid_standard?(:iso_639)).to be_false
+      expect(LanguageCodes.valid_standard?(:iso_639)).to eq(false)
     end
 
     it 'accepts a string' do
-      expect(LanguageCodes.valid_standard?('iso_639_2')).to be_true
+      expect(LanguageCodes.valid_standard?('iso_639_2')).to eq(true)
     end
   end
 
   describe '#valid_code?' do
     it 'returns true if the code is present in the given standard' do
-      expect(LanguageCodes.valid_code?(:spa, :iso_639_2)).to be_true
+      expect(LanguageCodes.valid_code?(:spa, :iso_639_2)).to eq(true)
     end
 
     it 'returns false if the code is not present in the given standard' do
-      expect(LanguageCodes.valid_code?(:foo, :iso_639_2)).to be_false
+      expect(LanguageCodes.valid_code?(:foo, :iso_639_2)).to eq(false)
     end
 
     it 'raises exception if the standard is invalid' do
@@ -52,7 +52,7 @@ describe LanguageCodes do
     end
 
     it 'accepts strings' do
-      expect(LanguageCodes.valid_code?('spa', 'iso_639_2')).to be_true
+      expect(LanguageCodes.valid_code?('spa', 'iso_639_2')).to eq(true)
     end
   end
 
@@ -158,4 +158,4 @@ describe LanguageCodes do
       expect(LanguageCodes.standards_for_language('FooBar')).to eq([])
     end
   end
-end
+end

data/spec/shared/languages_spec.rb

@@ -89,13 +89,13 @@ describe Languages do
   describe "#is_rtl?" do
     it "should return true for certain locales" do
       [:ar, :he, :ur, :fa].each do |locale|
-        expect(Languages.is_rtl?(locale)).to be_true
+        expect(Languages.is_rtl?(locale)).to eq(true)
       end
     end
 
     it "should return false for certain locales" do
       [:en, :es, :hu, :ja].each do |locale|
-        expect(Languages.is_rtl?(locale)).to be_false
+        expect(Languages.is_rtl?(locale)).to eq(false)
       end
     end
 

data/spec/shared/locale_spec.rb

@@ -121,27 +121,27 @@ describe Locale do
 
   describe '.valid?' do
     it 'returns true if all subtags are valid' do
-      expect(Locale.valid?('en')).to be_true
-      expect(Locale.valid?('en-latn')).to be_true
-      expect(Locale.valid?('en-latn-us')).to be_true
-      expect(Locale.valid?('en-latn-us-fonipa')).to be_true
+      expect(Locale.valid?('en')).to eq(true)
+      expect(Locale.valid?('en-latn')).to eq(true)
+      expect(Locale.valid?('en-latn-us')).to eq(true)
+      expect(Locale.valid?('en-latn-us-fonipa')).to eq(true)
     end
 
     it 'returns false if any subtag is invalid' do
-      expect(Locale.valid?('xz')).to be_false
-      expect(Locale.valid?('en-fooo')).to be_false
-      expect(Locale.valid?('en-latn-XZ')).to be_false
-      expect(Locale.valid?('en-latn-us-foooo')).to be_false
+      expect(Locale.valid?('xz')).to eq(false)
+      expect(Locale.valid?('en-fooo')).to eq(false)
+      expect(Locale.valid?('en-latn-XZ')).to eq(false)
+      expect(Locale.valid?('en-latn-us-foooo')).to eq(false)
     end
   end
 
   describe '.grandfathered?' do
     it 'returns true if the given locale is considered "grandfathered"' do
-      expect(Locale.grandfathered?('i-navajo')).to be_true
+      expect(Locale.grandfathered?('i-navajo')).to eq(true)
     end
 
     it 'returns false if the given locale is not considered "grandfathered"' do
-      expect(Locale.grandfathered?('en-latn-us')).to be_false
+      expect(Locale.grandfathered?('en-latn-us')).to eq(false)
     end
   end
 

data/spec/shared/numbers_spec.rb

@@ -12,23 +12,23 @@ describe Numbers do
     let(:symbols) { { nan: 'NaN', minus_sign: '-' } }
 
     it 'returns numerical symbols for default locale' do
-      stub(TwitterCldr).locale { :jp }
-      stub(TwitterCldr).get_locale_resource(:jp, :numbers) { { jp: { numbers: { symbols: symbols } } } }
+      allow(TwitterCldr).to receive(:locale).and_return(:jp)
+      allow(TwitterCldr).to receive(:get_locale_resource).with(:jp, :numbers).and_return(jp: { numbers: { symbols: symbols } })
       expect(TwitterCldr::Shared::Numbers.symbols).to eq(symbols)
     end
 
     it 'returns numerical symbols for default locale' do
-      stub(TwitterCldr).get_locale_resource(:np, :numbers) { { np: { numbers: { symbols: symbols } } } }
+      allow(TwitterCldr).to receive(:get_locale_resource).with(:np, :numbers).and_return(np: { numbers: { symbols: symbols } })
       expect(TwitterCldr::Shared::Numbers.symbols(:np)).to eq(symbols)
     end
 
     it 'converts locale' do
-      stub(TwitterCldr).get_locale_resource(:'zh-Hant', :numbers) { { :'zh-Hant' => { numbers: { symbols: symbols } } } }
+      allow(TwitterCldr).to receive(:get_locale_resource).with(:'zh-Hant', :numbers).and_return(:'zh-Hant' => { numbers: { symbols: symbols } })
       expect(TwitterCldr::Shared::Numbers.symbols('zh-tw')).to eq(symbols)
     end
 
     it 'returns nil if the resource is missing' do
-      stub(TwitterCldr).get_locale_resource(:nop, :numbers) { nil }
+      allow(TwitterCldr).to receive(:get_locale_resource).with(:nop, :numbers).and_return(nil)
       expect(TwitterCldr::Shared::Numbers.symbols(:nop)).to be_nil
     end
   end

data/spec/shared/phone_codes_spec.rb

@@ -28,7 +28,9 @@ describe PhoneCodes do
     let(:code)      { '123' }
     let(:territory) { :br }
 
-    before(:each) { mock(PhoneCodes).resource { { territory => code } } }
+    before(:each) do
+      expect(PhoneCodes).to receive(:resource).and_return({ territory => code })
+    end
 
     it 'returns phone code for a given territory' do
       expect(PhoneCodes.code_for_territory(territory)).to eq(code)
@@ -46,4 +48,4 @@ describe PhoneCodes do
       expect(PhoneCodes.code_for_territory(territory.to_s.upcase)).to eq(code)
     end
   end
-end
+end

data/spec/shared/postal_code_generator_spec.rb

@@ -68,7 +68,7 @@ describe PostalCodeGenerator do
     end
 
     it "should attempt to generate more samples if the set doesn't contain enough (but shouldn't infinite loop)" do
-      mock.proxy(limited_generator).generate.at_least(10)
+      expect(limited_generator).to receive(:generate).at_least(10).times.and_call_original
       expect(limited_generator.sample(10).size).to be < 10
     end
   end

data/spec/shared/properties_database_spec.rb

@@ -69,19 +69,19 @@ describe PropertiesDatabase do
 
     describe '#include?' do
       it 'returns true if the database contains the property name' do
-        expect(database.include?('Age')).to be_true
+        expect(database.include?('Age')).to eq(true)
       end
 
       it 'returns true if the database contains the property name/value pair' do
-        expect(database.include?('Age', '1.1')).to be_true
+        expect(database.include?('Age', '1.1')).to eq(true)
       end
 
       it "returns false if the database doesn't contain the property name" do
-        expect(database.include?('foo')).to be_false
+        expect(database.include?('foo')).to eq(false)
       end
 
       it "returns false if the database doesn't contain the property name/value pair" do
-        expect(database.include?('Age', 'foo')).to be_false
+        expect(database.include?('Age', 'foo')).to eq(false)
       end
     end
 
@@ -148,8 +148,8 @@ describe PropertiesDatabase do
 
       it 'delegates normalization to a normalizer' do
         normalizer = Object.new
-        stub(database).normalizer { normalizer }
-        mock(normalizer).normalize(property_name, property_value)
+        allow(database).to receive(:normalizer).and_return(normalizer)
+        expect(normalizer).to receive(:normalize).with(property_name, property_value)
         database.normalize(property_name, property_value)
       end
     end

data/spec/shared/territories_containment_spec.rb

@@ -46,32 +46,32 @@ describe TerritoriesContainment do
 
   describe '.contains?' do
     it 'returns true if the first territory (immediately) contains the second one' do
-      expect(TerritoriesContainment.contains?('151', 'RU')).to be_true
+      expect(TerritoriesContainment.contains?('151', 'RU')).to eq(true)
     end
 
     it 'returns true if the first territory (non-immediately) contains the second one' do
-      expect(TerritoriesContainment.contains?('419', 'BZ')).to be_true
+      expect(TerritoriesContainment.contains?('419', 'BZ')).to eq(true)
     end
 
     it 'returns true if a territory is part of multiple parent territories' do
-      expect(TerritoriesContainment.contains?('019', '013')).to be_true
-      expect(TerritoriesContainment.contains?('419', '013')).to be_true
+      expect(TerritoriesContainment.contains?('019', '013')).to eq(true)
+      expect(TerritoriesContainment.contains?('419', '013')).to eq(true)
     end
 
     it 'returns true if the first territory is a top-level territory' do
-      expect(TerritoriesContainment.contains?('001', '145')).to be_true
+      expect(TerritoriesContainment.contains?('001', '145')).to eq(true)
     end
 
     it 'returns false if the first territory does not contain the second one' do
-      expect(TerritoriesContainment.contains?('419', 'RU')).to be_false
+      expect(TerritoriesContainment.contains?('419', 'RU')).to eq(false)
     end
 
     it 'returns false if the second territory is a top-level territory' do
-      expect(TerritoriesContainment.contains?('419', '001')).to be_false
+      expect(TerritoriesContainment.contains?('419', '001')).to eq(false)
     end
 
     it 'returns false if both territories are identical' do
-      expect(TerritoriesContainment.contains?('RU', 'RU')).to be_false
+      expect(TerritoriesContainment.contains?('RU', 'RU')).to eq(false)
     end
 
     it 'raises an exception is the first territory is invalid' do

data/spec/shared/territories_spec.rb

@@ -117,12 +117,16 @@ describe Territories do
   end
 
   describe "#deep_normalize_territory_code_keys" do
-    Territories.deep_normalize_territory_code_keys(
-      { "is" => [ { "US" => "United States",
-                    5 => "Suður-Ameríka" },
-                  { "009" => "Eyjaálfa" } ] }
-    ).should == { is: [ { us: "United States" }, { } ] }
-  end
+    it 'normalizes correctly' do
+      normalized = Territories.deep_normalize_territory_code_keys({
+        "is" => [
+          { "US" => "United States", 5 => "Suður-Ameríka" },
+          { "009" => "Eyjaálfa" }
+        ]
+      })
 
+      expect(normalized).to eq({ is: [{ us: "United States" }, {}] })
+    end
+  end
 end
 

data/spec/shared/territory_spec.rb

@@ -15,7 +15,7 @@ describe Territory do
     let(:parents) { %w[013 territory parents] }
 
     it 'delegates to TerritoriesContainment.parents' do
-      mock(TerritoriesContainment).parents(code) { parents }
+      expect(TerritoriesContainment).to receive(:parents).with(code).and_return(parents)
       expect(territory.parents).to eq(parents)
     end
   end
@@ -24,18 +24,17 @@ describe Territory do
     let(:children) { %w[013 territory children] }
 
     it 'delegates to TerritoriesContainment.children' do
-      mock(TerritoriesContainment).children(code) { children }
+      expect(TerritoriesContainment).to receive(:children).with(code).and_return(children)
       expect(territory.children).to eq(children)
     end
   end
 
   describe '#contains?' do
     let(:other_code) { 'RU' }
-    let(:result) { 'containment result' }
 
     it 'delegates to TerritoriesContainment.contains?' do
-      mock(TerritoriesContainment).contains?(code, other_code) { result }
-      expect(territory.contains?(other_code)).to be_true
+      expect(TerritoriesContainment).to receive(:contains?).with(code, other_code)
+      territory.contains?(other_code)
     end
   end
 end

data/spec/spec_helper.rb

@@ -4,7 +4,6 @@
 # http://www.apache.org/licenses/LICENSE-2.0
 
 require 'rspec'
-require 'rspec/autorun' # somehow makes rcov work with rspec
 require 'twitter_cldr'
 require 'pry-nav'
 require 'coveralls'
@@ -46,7 +45,7 @@ module I18n
 end
 
 RSpec.configure do |config|
-  config.mock_with :rr
+  # config.mock_with :rr
 
   config.filter_run(focus: true)
   config.run_all_when_everything_filtered = true

data/spec/twitter_cldr_spec.rb

@@ -8,29 +8,29 @@ require 'spec_helper'
 describe TwitterCldr do
   describe "#supported_locale?" do
     it "should return true if the locale is supported" do
-      expect(TwitterCldr.supported_locale?(:es)).to be_true
-      expect(TwitterCldr.supported_locale?("es")).to be_true
+      expect(TwitterCldr.supported_locale?(:es)).to eq(true)
+      expect(TwitterCldr.supported_locale?("es")).to eq(true)
     end
 
     it "should return false if the locale isn't supported" do
-      expect(TwitterCldr.supported_locale?(:bogus)).to be_false
-      expect(TwitterCldr.supported_locale?("bogus")).to be_false
+      expect(TwitterCldr.supported_locale?(:bogus)).to eq(false)
+      expect(TwitterCldr.supported_locale?("bogus")).to eq(false)
     end
 
     it "should return true if the given locale code is twitter-specific" do
-      expect(TwitterCldr.supported_locale?(:'zh-cn')).to be_true
-      expect(TwitterCldr.supported_locale?(:'zh-tw')).to be_true
-      expect(TwitterCldr.supported_locale?(:msa)).to be_true
+      expect(TwitterCldr.supported_locale?(:'zh-cn')).to eq(true)
+      expect(TwitterCldr.supported_locale?(:'zh-tw')).to eq(true)
+      expect(TwitterCldr.supported_locale?(:msa)).to eq(true)
     end
 
     it "should work with lowercase region codes" do
-      expect(TwitterCldr.supported_locale?('en-gb')).to be_true
-      expect(TwitterCldr.supported_locale?('zh-hant')).to be_true
+      expect(TwitterCldr.supported_locale?('en-gb')).to eq(true)
+      expect(TwitterCldr.supported_locale?('zh-hant')).to eq(true)
     end
 
     it "should work with upper case region codes" do
-      expect(TwitterCldr.supported_locale?('en-GB')).to be_true
-      expect(TwitterCldr.supported_locale?('zh-Hant')).to be_true
+      expect(TwitterCldr.supported_locale?('en-GB')).to eq(true)
+      expect(TwitterCldr.supported_locale?('zh-Hant')).to eq(true)
     end
   end
 
@@ -272,9 +272,9 @@ describe TwitterCldr do
       expect do
         TwitterCldr.with_locale(:es) do
           locale_inside_block = TwitterCldr.locale
-          raise "Error!"
+          raise RuntimeError, "Error!"
         end
-      end.to raise_error
+      end.to raise_error(RuntimeError, "Error!")
 
       expect(locale_inside_block).to eq(:es)
       expect(TwitterCldr.locale).to eq(:en)
@@ -291,7 +291,7 @@ describe TwitterCldr do
     it "doesn't mess up if the given locale isn't supported" do
       TwitterCldr.locale = :pt
       expect(TwitterCldr.locale).to eq(:pt)
-      expect { TwitterCldr.with_locale(:xx) {} }.to raise_error
+      expect { TwitterCldr.with_locale(:xx) {} }.to raise_error(RuntimeError, 'Unsupported locale')
       expect(TwitterCldr.locale).to eq(:pt)
     end
 
@@ -302,9 +302,9 @@ describe TwitterCldr do
       expect do
         TwitterCldr.with_locale(:es) do
           locale_inside_block = TwitterCldr.locale
-          raise "Error!"
+          raise RuntimeError, "Error!"
         end
-      end.to raise_error
+      end.to raise_error(RuntimeError, "Error!")
 
       expect(locale_inside_block).to eq(:es)
       expect(TwitterCldr.locale).to eq(:en)
@@ -324,8 +324,8 @@ describe TwitterCldr do
 
   describe '#get_resource' do
     it 'delegates to resources' do
-      stub(resources).get_resource(:shared, :currencies) { 'result' }
-      stub(TwitterCldr).resources { resources }
+      allow(resources).to receive(:get_resource).with(:shared, :currencies).and_return('result')
+      allow(TwitterCldr).to receive(:resources).and_return(resources)
 
       expect(TwitterCldr.get_resource(:shared, :currencies)).to eq('result')
     end
@@ -333,8 +333,8 @@ describe TwitterCldr do
 
   describe '#get_locale_resource' do
     it 'delegates to resources' do
-      stub(resources).get_locale_resource(:de, :numbers) { 'result' }
-      stub(TwitterCldr).resources { resources }
+      allow(resources).to receive(:get_locale_resource).with(:de, :numbers).and_return('result')
+      allow(TwitterCldr).to receive(:resources).and_return(resources)
 
       expect(TwitterCldr.get_locale_resource(:de, :numbers)).to eq('result')
     end