countries 4.2.3 → 5.1.0

data/lib/countries/tasks/geocoding.rake

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'geocoder'
 require 'retryable'
 
@@ -16,7 +18,7 @@ def geocode(query, params)
   Retryable.retryable(tries: 3, sleep: ->(n) { 2**n }) do
     Geocoder.search(query, params: params).first
   end
-rescue => e
+rescue Geocoder::Error, Geocoder::LookupTimeout => e
   warn "Attempts exceeded for query #{query}, last error was #{e.message}"
   nil
 end
@@ -26,7 +28,7 @@ def load_country_yaml(alpha2)
 end
 
 def save_country_yaml(alpha2, data)
-  File.open(File.join(ISO3166_ROOT_PATH, 'lib', 'countries', 'data', 'countries', "#{alpha2}.yaml"), 'w+') { |f| f.write data.to_yaml }
+  File.write(File.join(ISO3166_ROOT_PATH, 'lib', 'countries', 'data', 'countries', "#{alpha2}.yaml"), data.to_yaml)
 end
 
 def country_codes
@@ -44,7 +46,10 @@ namespace :geocode do
       data = load_country_yaml(country.alpha2)
 
       next unless (result = geocode(country.iso_short_name, {region: country.alpha2}))
-      puts "WARNING:: Geocoder returned something that was not a country for #{country.alpha2}" unless result.types.include?('country')
+
+      unless result.types.include?('country')
+        puts "WARNING:: Geocoder returned something that was not a country for #{country.alpha2}"
+      end
       geometry = result.geometry
 
       # Extract center point data
@@ -55,6 +60,7 @@ namespace :geocode do
 
       # Extract bounding box data
       next unless geometry['bounds']
+
       data[code]['geo']['bounds'] = geometry['bounds']
       data[code]['geo']['min_latitude'] = geometry['bounds']['southwest']['lat']
       data[code]['geo']['min_longitude'] = geometry['bounds']['southwest']['lng']
@@ -73,10 +79,10 @@ namespace :geocode do
     ISO3166::Country.all.select(&:subdivisions?).each do |c|
       # Iterate subdivisions
       state_data = c.subdivisions.dup
-      state_data.reject { |_, data| data['geo'] }.each do |code, data|
+      state_data.reject { |_, data| data['geo'] }.each do |code, _|
         location = "#{c.alpha2}-#{code}"
 
-        next unless (result = geocode(location, {region: c.alpha2}))
+        next unless (result = geocode(location, { region: c.alpha2 }))
 
         geometry = result.geometry
         if geometry['location']
@@ -84,14 +90,17 @@ namespace :geocode do
           state_data[code]['geo']['latitude'] = geometry['location']['lat']
           state_data[code]['geo']['longitude'] = geometry['location']['lng']
         end
+
         next unless geometry['bounds']
+
         state_data[code]['geo']['min_latitude'] = geometry['bounds']['southwest']['lat']
         state_data[code]['geo']['min_longitude'] = geometry['bounds']['southwest']['lng']
         state_data[code]['geo']['max_latitude'] = geometry['bounds']['northeast']['lat']
         state_data[code]['geo']['max_longitude'] = geometry['bounds']['northeast']['lng']
       end
       # Write updated YAML for current country
-      File.open(File.join(ISO3166_ROOT_PATH, 'lib', 'countries', 'data', 'subdivisions', "#{c.alpha2}.yaml"), 'w+') { |f| f.write state_data.to_yaml }
+      out = File.join(ISO3166_ROOT_PATH, 'lib', 'countries', 'data', 'subdivisions', "#{c.alpha2}.yaml")
+      File.write(out, state_data.to_yaml)
     end
   end
 end

data/lib/countries/tasks/postal_codes.rake

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 namespace :postal_codes do
   desc 'Retrieve and update postal codes and their format'
   task :update do
@@ -20,13 +22,13 @@ namespace :postal_codes do
       json = JSON.parse(response) rescue {}
       puts ' - Returned empty data. Skipping ' and next if json.empty?
 
-      postal_code = ['postal_code', !!json['zip']]
+      postal_code = ['postal_code', !json['zip'].nil?]
       postal_code_format = ['postal_code_format', json['zip']]
 
       if postal_code_index
         data[postal_code_index] = postal_code
       else
-        postal_code_index = data.find_index { |d| d[0] == 'nationality' } + 1 || data.size
+        postal_code_index = (data.find_index { |d| d[0] == 'nationality' } + 1) || data.size
         data.insert(postal_code_index, postal_code)
       end
 
@@ -42,7 +44,7 @@ namespace :postal_codes do
 
       yaml[country_code] = data.to_h
 
-      File.open(country_file, 'w') { |file| file.write(yaml.to_yaml) }
+      File.write(country_file, yaml.to_yaml)
     end
   end
 end

data/lib/countries/timezones.rb

@@ -1,13 +1,16 @@
+# frozen_string_literal: true
+
 module ISO3166
   # Extend Country class with support for timezones. Requires the  {tzinfo}[https://github.com/tzinfo/tzinfo] gem
   #
   #   gem 'tzinfo'
   #
   module TimezoneExtensions
+    # TODO: rename method to tz_country or something similar
     def timezones
-      @tz_country ||= TZInfo::Country.get(alpha2)
+      @timezones ||= TZInfo::Country.get(alpha2)
     end
   end
 end
 
-ISO3166::Country.send(:include, ISO3166::TimezoneExtensions)
+ISO3166::Country.include ISO3166::TimezoneExtensions

data/lib/countries/translations.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ISO3166
   # Extend the hash class to allow locale lookup fall back behavior
   #

data/lib/countries/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Countries
-  VERSION = '4.2.3'.freeze
+  VERSION = '5.1.0'.freeze
 end

data/lib/countries.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'sixarm_ruby_unaccent'
 
 require 'countries/version'

data/spec/00_global_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 describe 'global Country class', order: :defined do
   context "when loaded via 'iso3166' existence" do
     subject { defined?(Country) }

data/spec/configuration_spec.rb

@@ -1,4 +1,5 @@
-# encoding: utf-8
+# frozen_string_literal: true
+
 require 'spec_helper'
 require 'i18n'
 
@@ -16,14 +17,14 @@ describe 'ISO3166.configuration' do
   end
 
   it 'locales are assumed from I18n.available_locales' do
-    I18n.available_locales = [:de, :en]
+    I18n.available_locales = %i[de en]
     ISO3166.reset
     expect(ISO3166::Country.new('DE').translation(:de)).to eq 'Deutschland'
     expect(ISO3166::Country.new('DE').translation(:es)).to eq nil
   end
 
   it 'unsupported locales do not affect supported locales' do
-    I18n.available_locales = [:de, :en, :unsupported]
+    I18n.available_locales = %i[de en unsupported]
     ISO3166.reset
     expect(ISO3166::Country.new('DE').translation(:de)).to eq 'Deutschland'
     expect(ISO3166::Country.new('DE').translation(:es)).to eq nil
@@ -36,7 +37,7 @@ describe 'ISO3166.configuration' do
   end
 
   it 'locales can be changed' do
-    ISO3166.configuration.locales = [:es, :de, :en]
+    ISO3166.configuration.locales = %i[es de en]
     expect(ISO3166::Country.new('DE').translation(:es)).to eq 'Alemania'
     expect(ISO3166::Country.new('DE').translation(:en)).to eq 'Germany'
     expect(ISO3166::Country.new('DE').translation(:de)).to eq 'Deutschland'
@@ -44,7 +45,12 @@ describe 'ISO3166.configuration' do
 
   it 'locales can be changed with a block' do
     ISO3166.configure do |config|
-      config.locales = [:af, :am, :ar, :as, :az, :be, :bg, :bn, :br, :bs, :ca, :cs, :cy, :da, :de, :dz, :el, :en, :eo, :es, :et, :eu, :fa, :fi, :fo, :fr, :ga, :gl, :gu, :he, :hi, :hr, :hu, :hy, :ia, :id, :is, :it, :ja, :ka, :kk, :km, :kn, :ko, :ku, :lt, :lv, :mi, :mk, :ml, :mn, :mr, :ms, :mt, :nb, :ne, :nl, :nn, :oc, :or, :pa, :pl, :ps, :pt, :ro, :ru, :rw, :si, :sk, :sl, :so, :sq, :sr, :sv, :sw, :ta, :te, :th, :ti, :tk, :tl, :tr, :tt, :ug, :uk, :ve, :vi, :wa, :wo, :xh, :zh, :zu]
+      config.locales = %i[af am ar as az be bg bn br bs ca cs cy da de dz el en
+                          eo es et eu fa fi fo fr ga gl gu he hi hr hu hy ia id
+                          is it ja ka kk km kn ko ku lt lv mi mk ml mn mr ms mt
+                          nb ne nl nn oc or pa pl ps pt ro ru rw si sk sl so sq
+                          sr sv sw ta te th ti tk tl tr tt ug uk ve vi wa wo xh
+                          zh zu]
     end
 
     expect(ISO3166::Country.new('DE').translations.size).to eq 92

data/spec/country_spec.rb

@@ -1,4 +1,4 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
 require 'spec_helper'
 NUM_OF_COUNTRIES = 249
@@ -48,7 +48,9 @@ describe ISO3166::Country do
   end
 
   it 'should return alternate names' do
-    expect(country.unofficial_names).to eq(['United States', 'USA', 'Murica', 'Vereinigte Staaten von Amerika', 'États-Unis', 'Estados Unidos', 'アメリカ合衆国', 'Verenigde Staten'])
+    expect(country.unofficial_names).to eq(['United States', 'USA', 'Murica',
+                                 'Vereinigte Staaten von Amerika', 'États-Unis',
+                                 'Estados Unidos', 'アメリカ合衆国', 'Verenigde Staten'])
   end
 
   it 'should return translations' do
@@ -85,7 +87,7 @@ describe ISO3166::Country do
     expect(country.postal_code_format).to_not be_nil
 
     regex = Regexp.new(country.postal_code_format)
-    expect(regex).to match("12345-6789")
+    expect(regex).to match('12345-6789')
 
     antarctica = ISO3166::Country.search('AQ')
     expect(antarctica.postal_code_format).to be_nil
@@ -123,7 +125,7 @@ describe ISO3166::Country do
     let(:country) { ISO3166::Country.search('BE') }
 
     it 'should return its local names based on its languages' do
-      expect(country.local_names).to match_array(%w(België Belgique Belgien))
+      expect(country.local_names).to match_array(%w[België Belgique Belgien])
     end
 
     it 'should return its first local name' do
@@ -219,7 +221,7 @@ describe ISO3166::Country do
   end
 
   describe 'subdivisions' do
-    let(:virginia) { country.states['VA'] }
+    let(:virginia) { country.subdivisions['VA'] }
     it 'should return an empty hash for a country with no ISO3166-2' do
       expect(ISO3166::Country.search('VA').subdivisions.size).to eq(0)
     end
@@ -228,8 +230,8 @@ describe ISO3166::Country do
       expect(country.subdivisions.size).to eq(57)
     end
 
-    it 'should be available through states' do
-      expect(country.states.size).to eq(57)
+    it '#states should be deprecated' do
+      expect {country.states}.to output.to_stderr
     end
 
     it 'should be a subdivision object' do
@@ -249,6 +251,60 @@ describe ISO3166::Country do
     end
   end
 
+  describe 'subdivision_types' do
+    it "should return an array of subdivision types" do
+      expect(country.subdivision_types).to contain_exactly('district', 'state', 'outlying_area')
+    end
+
+    it "should return an array of subdivision types even if there is only a single type" do
+      expect(ISO3166::Country['LI'].subdivision_types).to contain_exactly('commune')
+    end
+
+    it "should return an empty array if country has no subdivisions" do
+      expect(ISO3166::Country['AS'].subdivisions?).to be_falsey
+      expect(ISO3166::Country['AS'].subdivision_types).to eq([])
+    end
+  end
+
+  describe 'subdivisions_of_types' do
+    it "given a single type, should return an array of subdivisions that match the type" do
+      us_states = country.subdivisions_of_types(%w[state])
+      expect(us_states.size).to eq(50)
+      dc = country.subdivisions_of_types(%w[district])
+      expect(dc.size).to eq(1)
+    end
+
+    it "given multiple types, should return an array of subdivisions matching the types" do
+      us_states_plus_dc = country.subdivisions_of_types(%w[state district])
+      expect(us_states_plus_dc.size).to eq(51)
+    end
+
+    it "given multiple types where at least one does not exist for that country, should work without issue" do
+      us_states_plus_dc = country.subdivisions_of_types(%w[state district governorate])
+      expect(us_states_plus_dc.size).to eq(51)
+    end
+
+    it "given only types that do not exist for that country, should return an empty collection" do
+      should_be_empty = ISO3166::Country['PT'].subdivisions_of_types(%w[state county])
+      expect(should_be_empty).to be_empty
+    end
+  end
+
+  describe 'humanized_subdivision_types' do
+    it "should return an array of humanized subdivision types" do
+      expect(country.humanized_subdivision_types).to contain_exactly('District', 'State', 'Outlying area')
+    end
+
+    it "should return an array of subdivision types even if there is only a single type" do
+      expect(ISO3166::Country['LI'].humanized_subdivision_types).to contain_exactly('Commune')
+    end
+
+    it "should return an empty array if country has no subdivisions" do
+      expect(ISO3166::Country['AS'].subdivisions?).to be_falsey
+      expect(ISO3166::Country['AS'].humanized_subdivision_types).to eq([])
+    end
+  end
+
   describe 'subdivision_names_with_codes' do
     it 'should return an alphabetized list of all subdivisions names with codes' do
       subdivisions = ISO3166::Country.search('EG').subdivision_names_with_codes
@@ -259,7 +315,7 @@ describe ISO3166::Country do
     end
 
     it 'should return an alphabetized list of subdivision names translated to current locale with codes' do
-      ISO3166.configuration.locales = [:es, :de, :en]
+      ISO3166.configuration.locales = %i[es de en]
 
       subdivisions = ISO3166::Country.search('EG').subdivision_names_with_codes(:es)
       expect(subdivisions).to be_an(Array)
@@ -328,7 +384,7 @@ describe ISO3166::Country do
       countries = ISO3166::Country.all_translated('fr')
       expect(countries).to be_an(Array)
       expect(countries.first).to be_a(String)
-      expect(countries.first).to eq('Aruba')
+      expect(countries.first).to eq('Andorre')
       # countries missing the desired locale will not be added to the list
       # so all 250 countries may not be returned, 'fr' returns 249, for example
       expect(countries.size).to eq(NUM_OF_COUNTRIES)
@@ -338,7 +394,7 @@ describe ISO3166::Country do
       countries = ISO3166::Country.all_translated
       expect(countries).to be_an(Array)
       expect(countries.first).to be_a(String)
-      expect(countries.first).to eq('Aruba')
+      expect(countries.first).to eq('Andorra')
       expect(countries.size).to eq(NUM_OF_COUNTRIES)
     end
 
@@ -371,11 +427,11 @@ describe ISO3166::Country do
       expect(countries.first[0]).to be_a(String)
       expect(countries.first[0]).to eq('Afghanistan')
       expect(countries.size).to eq(NUM_OF_COUNTRIES)
-      expect(countries.any?{|pair| !pair[0].html_safe?}).to eq(false)
+      expect(countries.any? { |pair| !pair[0].html_safe? }).to eq(false)
     end
 
     it 'should return an alphabetized list of all country names translated to current locale with ISOCODE alpha2' do
-      ISO3166.configuration.locales = [:es, :de, :en]
+      ISO3166.configuration.locales = %i[es de en]
 
       countries = ISO3166::Country.all_names_with_codes(:es)
       expect(countries).to be_an(Array)
@@ -395,7 +451,7 @@ describe ISO3166::Country do
     end
 
     it 'should return an alphabetized list of all country names translated to current locale with ISOCODE alpha2' do
-      ISO3166.configuration.locales = [:es, :de, :en]
+      ISO3166.configuration.locales = %i[es de en]
 
       countries = ISO3166::Country.all_names_with_codes(:es)
       expect(countries).to be_an(Array)
@@ -407,7 +463,7 @@ describe ISO3166::Country do
 
   describe 'translation' do
     it 'should return the localized name for a country to the selected locale' do
-      ISO3166.configuration.locales = [:es, :de, :en]
+      ISO3166.configuration.locales = %i[es de en]
       countries = ISO3166::Country.new(:de).translation('de')
       expect(countries).to be_an(String)
       expect(countries).to eq('Deutschland')
@@ -426,7 +482,7 @@ describe ISO3166::Country do
 
     context 'should return variant locales' do
       it 'should return different value for Chinese variants' do
-        ISO3166.configuration.locales = [:'zh-cn', :'zh-hk', :'zh-tw']
+        ISO3166.configuration.locales = %i[zh-cn zh-hk zh-tw]
         name_cn = ISO3166::Country['TW'].translation('zh-cn')
         name_hk = ISO3166::Country['TW'].translation('zh-hk')
         name_tw = ISO3166::Country['TW'].translation('zh-tw')
@@ -434,7 +490,7 @@ describe ISO3166::Country do
       end
 
       it 'should return different value for Portuguese variants' do
-        ISO3166.configuration.locales = [:pt, :'pt-br']
+        ISO3166.configuration.locales = %i[pt pt-br]
         name_pt = ISO3166::Country['SG'].translation('pt')
         name_br = ISO3166::Country['SG'].translation('pt-br')
         expect([name_pt, name_br].uniq.size).to eql 2
@@ -446,8 +502,8 @@ describe ISO3166::Country do
     it 'should return an hash of all country names translated to the selected locale' do
       countries = ISO3166::Country.translations('fr')
       expect(countries).to be_an(Hash)
-      expect(countries.first[0]).to eq('AW')
-      expect(countries.first).to eq(%w(AW Aruba))
+      expect(countries.first[0]).to eq('AD')
+      expect(countries.first).to eq(%w[AD Andorre])
       # countries missing the desired locale will not be added to the list
       # so all 250 countries may not be returned, 'fr' returns 249, for example
       expect(countries.size).to eq(NUM_OF_COUNTRIES)
@@ -456,8 +512,8 @@ describe ISO3166::Country do
     it 'should return an hash of all country names in English if no locale is passed' do
       countries = ISO3166::Country.translations
       expect(countries).to be_an(Hash)
-      expect(countries.first[0]).to eq('AW')
-      expect(countries.first).to eq(%w(AW Aruba))
+      expect(countries.first[0]).to eq('AD')
+      expect(countries.first).to eq(%w[AD Andorra])
       expect(countries.size).to eq(NUM_OF_COUNTRIES)
     end
   end
@@ -648,7 +704,9 @@ describe ISO3166::Country do
 
     context 'when finding by invalid attribute' do
       it 'should raise an error' do
-        expect { ISO3166::Country.find_by_invalid('invalid') }.to raise_error(RuntimeError, "Invalid attribute name 'invalid'")
+        expect { ISO3166::Country.find_by_invalid('invalid') }.to(
+          raise_error(RuntimeError, "Invalid attribute name 'invalid'")
+        )
       end
     end
 
@@ -713,6 +771,49 @@ describe ISO3166::Country do
       end
     end
 
+    describe '#find_country_by_any_name' do
+      context 'when search name found' do
+        let(:uk) { ISO3166::Country.find_country_by_any_name('United Kingdom') }
+
+        it 'should be a country instance' do
+          expect(uk).to be_a(ISO3166::Country)
+          expect(uk.alpha2).to eq('GB')
+        end
+      end
+
+      context 'when search lowercase name found' do
+        let(:uk) { ISO3166::Country.find_country_by_any_name('united kingdom') }
+
+        it 'should be a country instance' do
+          expect(uk).to be_a(ISO3166::Country)
+          expect(uk.alpha2).to eq('GB')
+        end
+      end
+
+      context 'when the search term contains comma' do
+        let(:korea) { ISO3166::Country.find_country_by_any_name('Korea, Republic of') }
+
+        it 'should be a country instance' do
+          expect(korea).to be_a(ISO3166::Country)
+          expect(korea.alpha2).to eq('KR')
+        end
+      end
+
+      context 'when search translation found' do
+        before do
+          ISO3166.configure do |config|
+            config.locales = [:bs]
+          end
+        end
+        let(:uk) { ISO3166::Country.find_country_by_any_name('Velika Britanija') }
+
+        it 'should be a country instance' do
+          expect(uk).to be_a(ISO3166::Country)
+          expect(uk.alpha2).to eq('GB')
+        end
+      end
+    end
+
     context 'regression test for #388' do
       let(:no_country) { ISO3166::Country.find_country_by_translated_names(nil) }
 
@@ -729,6 +830,7 @@ describe ISO3166::Country do
         expect { uk }.to raise_error(RuntimeError)
       end
     end
+
     context 'when search name not found' do
       let(:bogus) { ISO3166::Country.find_country_by_unofficial_names('Does not exist') }
 
@@ -785,8 +887,9 @@ describe ISO3166::Country do
 
     context 'when finding by invalid attribute' do
       it 'should raise an error' do
-        expect { ISO3166::Country.find_country_by_invalid('invalid') }.to raise_error(RuntimeError,
-                                                                                      "Invalid attribute name 'invalid'")
+        expect { ISO3166::Country.find_country_by_invalid('invalid') }.to(
+          raise_error(RuntimeError, "Invalid attribute name 'invalid'")
+        )
       end
     end
 
@@ -847,16 +950,6 @@ describe ISO3166::Country do
     end
   end
 
-  describe 'names in Data' do
-    it 'should be unique (to allow .find_by_name work properly)' do
-      names = ISO3166::Data.cache.map do |_k, v|
-        [v['iso_short_name'], v['unofficial_names']].flatten.uniq
-      end.flatten
-
-      expect(names.size).to eq(names.uniq.size)
-    end
-  end
-
   describe 'Norway' do
     let(:norway) { ISO3166::Country.search('NO') }
 
@@ -947,7 +1040,7 @@ describe ISO3166::Country do
 
     it 'should contain all keys for vat_rates' do
       expect(belgium.vat_rates).to be_a(Hash)
-      expect(belgium.vat_rates.keys).to eq(%w(standard reduced super_reduced parking))
+      expect(belgium.vat_rates.keys).to eq(%w[standard reduced super_reduced parking])
     end
 
     it 'should return an array of reduced vat rates' do
@@ -1021,7 +1114,7 @@ describe ISO3166::Country do
 
     subject { ISO3166::Country.pluck(*args) }
 
-    it "returns empty arrays" do
+    it 'returns empty arrays' do
       expect(subject.first).to be_empty
       expect(subject.last).to be_empty
     end
@@ -1029,9 +1122,9 @@ describe ISO3166::Country do
     context "when asking for alpha2, alpha3 and iso_short_name" do
       let(:args) { [:alpha2, :alpha3, :iso_short_name] }
 
-      it "returns the correct values" do
-        expect(subject.first).to eq(["AD", "AND", "Andorra"])
-        expect(subject.last).to eq(["ZW", "ZWE", "Zimbabwe"])
+      it 'returns the correct values' do
+        expect(subject.first).to eq(%w[AD AND Andorra])
+        expect(subject.last).to eq(%w[ZW ZWE Zimbabwe])
       end
     end
   end