countries 2.1.2 → 3.1.0

data/lib/countries/sources/cldr/subdivision.rb

@@ -0,0 +1,34 @@
+module Sources
+  module CLDR
+    class Subdivision
+      attr_reader :xml, :language_code
+      def initialize(language_code:, xml:)
+        @language_code = language_code
+        @xml = xml
+      end
+
+      def text
+        xml.text
+      end
+
+      def country_code
+        type[0..1].upcase
+      end
+
+      def code
+        type[2..-1].upcase
+      end
+
+      def type
+        xml.attributes['type'].value.delete('-')
+      end
+
+      def to_h
+        data = {}
+        data['translations'] ||= {}
+        data['translations'][language_code] = text
+        data
+      end
+    end
+  end
+end

data/lib/countries/sources/cldr/subdivision_updater.rb

@@ -0,0 +1,34 @@
+require 'active_support'
+require 'active_support/core_ext/hash/deep_merge'
+require 'nokogiri'
+require 'pry'
+
+module Sources
+  module CLDR
+    class SubdivisionUpdater
+      def call
+        d = Dir['./tmp/cldr/trunk/common/subdivisions/*.xml']
+        loader = Sources::Local::CachedLoader.new(Sources::Local::Subdivision)
+        d.each do |file_path|
+          language_data = Nokogiri::XML(File.read(file_path))
+          language_code = File.basename(file_path, '.*')
+          subdivisions = language_data.css('subdivision')
+          next if subdivisions.empty?
+          last_country_code_seen = nil
+
+          subdivisions.each_with_index do |subdivision, index|
+            subdivision = Sources::CLDR::Subdivision.new(language_code: language_code, xml: subdivision)
+            data = loader.load(subdivision.country_code)
+            data[subdivision.code] ||= {}
+            data[subdivision.code] = data[subdivision.code].deep_merge(subdivision.to_h)
+            if (last_country_code_seen && last_country_code_seen != subdivision.country_code) || index == subdivisions.size - 1
+              puts "Updated #{subdivision.country_code} with language_code #{language_code}"
+              loader.save(subdivision.country_code, data)
+            end
+            last_country_code_seen = subdivision.country_code
+          end
+        end
+      end
+    end
+  end
+end

data/lib/countries/sources/local/cached_loader.rb

@@ -0,0 +1,27 @@
+module Sources
+  module Local
+    class CachedLoader
+      attr_reader :klass
+      def initialize(klass)
+        @klass = klass
+        @loaded_countries = {}
+      end
+
+      def from_cache(country_code)
+        @loaded_countries[country_code]
+      end
+
+      def load(country_code)
+        if (data = from_cache(country_code))
+          data
+        else
+          @loaded_countries[country_code] = klass.load(country_code)
+        end
+      end
+
+      def save(country_code, data)
+        klass.new(country_code).save(data)
+      end
+    end
+  end
+end

data/lib/countries/sources/local/subdivision.rb

@@ -0,0 +1,32 @@
+module Sources
+  module Local
+    class Subdivision
+      attr_reader :code
+      def initialize(code)
+        @code = code
+      end
+
+      def load
+        if File.exist?(file_path)
+          YAML.load_file(file_path) || {}
+        else
+          {}
+        end
+      end
+
+      def save(data)
+        File.open(file_path, 'w') { |f| f.write data.to_yaml }
+      rescue
+        puts "failed to read #{file}: #{$ERROR_INFO}"
+      end
+
+      def file_path
+        "lib/countries/data/subdivisions/#{code}.yaml"
+      end
+
+      def self.load(code)
+        new(code).load
+      end
+    end
+  end
+end

data/lib/countries/structure.rb

@@ -42,6 +42,7 @@ module ISO3166
     'languages_spoken' => [],
     'translations' => {},
     'postal_code' => nil,
+    'postal_code_format' => nil,
     'region' => nil,
     'unofficial_names' => [],
     'start_of_week' => 'monday',

data/lib/countries/tasks/geocoding.rake

@@ -32,7 +32,7 @@ def country_codes
 end
 
 namespace :geocode do
-  desc 'Retrieve and store subdivisions coordinates'
+  desc 'Retrieve and store countries coordinates'
   task :fetch_countries do
     require 'countries'
     # Iterate over countries
@@ -70,12 +70,12 @@ namespace :geocode do
 
   desc 'Retrieve and store subdivisions coordinates'
   task :fetch_subdivisions do
-    require 'countries'
+    require_relative '../../countries'
     # Iterate all countries with subdivisions
     ISO3166::Country.all.select(&:subdivisions?).each do |c|
       # Iterate subdivisions
       state_data = c.subdivisions.dup
-      state_data.reject { |_, data| data['latitude'] }.each do |code, data|
+      state_data.reject { |_, data| data['geo'] }.each do |code, data|
         location = "#{data['name']}, #{c.name}"
 
         # Handle special geocoding cases where Google defaults to well known
@@ -87,6 +87,7 @@ namespace :geocode do
         next unless (result = geocode(location))
         geometry = result.geometry
         if geometry['location']
+          state_data[code]['geo'] ||= {}
           state_data[code]['geo']['latitude'] = geometry['location']['lat']
           state_data[code]['geo']['longitude'] = geometry['location']['lng']
         end

data/lib/countries/tasks/postal_codes.rake

@@ -0,0 +1,48 @@
+namespace :postal_codes do
+  desc 'Retrieve and update postal codes and their format'
+  task :update do
+    require 'json'
+    require 'open-uri'
+    require 'yaml'
+
+    country_files = Dir['lib/countries/data/countries/*.yaml'].sort
+
+    country_files.each do |country_file|
+      yaml = YAML.load_file(country_file)
+      country_code = File.basename(country_file, File.extname(country_file))
+      print "\rUpdating #{country_code}"
+
+      data = yaml[country_code].to_a
+      postal_code_index = data.find_index { |d| d[0] == 'postal_code' }
+      postal_code_format_index = data.find_index { |d| d[0] == 'postal_code_format' }
+
+      response = URI.open("https://chromium-i18n.appspot.com/ssl-address/data/#{country_code}").read
+      json = JSON.parse(response) rescue {}
+      puts ' - Returned empty data. Skipping ' and next if json.empty?
+
+      postal_code = ['postal_code', !!json['zip']]
+      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
+        data.insert(postal_code_index, postal_code)
+      end
+
+      if json['zip']
+        if postal_code_format_index
+          data[postal_code_format_index] = postal_code_format
+        else
+          data.insert(postal_code_index + 1, postal_code_format)
+        end
+      elsif postal_code_format_index
+        data.delete_at(postal_code_format_index)
+      end
+
+      yaml[country_code] = data.to_h
+
+      File.open(country_file, 'w') { |file| file.write(yaml.to_yaml) }
+    end
+  end
+end

data/lib/countries/version.rb

@@ -1,3 +1,3 @@
 module Countries
-  VERSION = '2.1.2'.freeze
+  VERSION = '3.1.0'.freeze
 end

data/spec/00_global_spec.rb

@@ -0,0 +1,56 @@
+describe 'global Country class', order: :defined do
+  context "when loaded via 'iso3166' existence" do
+    subject { defined?(Country) }
+
+    it { is_expected.to be_falsey }
+  end
+
+  context "when loaded via 'global'" do
+    before { require 'countries/global' }
+
+    it 'does not pollute global namespace with Money gem' do
+      expect(defined?(Money)).not_to be
+      expect(ISO3166::Country.new('DE').respond_to?(:currency)).not_to be
+    end
+
+    describe 'existence' do
+      subject { defined?(Country) }
+
+      it { is_expected.to be_truthy }
+    end
+
+    describe 'superclass' do
+      subject { Country.superclass }
+
+      it { is_expected.to eq(ISO3166::Country) }
+    end
+
+    describe 'to_s' do
+      it 'should return the country name' do
+        expect(Country.new('GB').to_s).to eq('United Kingdom of Great Britain and Northern Ireland')
+      end
+    end
+
+    describe 'currency' do
+      it { expect(Country.new('GB').respond_to?(:currency)).not_to be }
+
+      context 'I enable currency extension via config' do
+        before { ISO3166.configuration.enable_currency_extension! }
+
+        it 'should add currency to global country' do
+          expect(Country.new('GB').currency).to be
+        end
+      end
+    end
+
+    context 'I enable currency extension via config' do
+      before { ISO3166.configuration.enable_currency_extension! }
+
+      it 'should add currency to global country' do
+        expect(Country.new('GB').currency).to be
+        expect(defined?(Money)).to be
+        expect(ISO3166::Country.new('DE').currency).to be
+      end
+    end
+  end
+end

data/spec/configuration_spec.rb

@@ -1,5 +1,6 @@
 # encoding: utf-8
 require 'spec_helper'
+require 'i18n'
 
 describe 'ISO3166.configuration' do
   it 'has a configuration' do

data/spec/country_spec.rb

@@ -3,6 +3,7 @@
 require 'spec_helper'
 NUM_OF_COUNTRIES = 249
 describe ISO3166::Country do
+  before { ISO3166.configuration.enable_currency_extension! }
   let(:country) { ISO3166::Country.search('US') }
 
   it 'allows to create a country object from a symbol representation of the alpha2 code' do
@@ -47,7 +48,7 @@ describe ISO3166::Country do
   end
 
   it 'should return alternate names' do
-    expect(country.names).to eq(['United States', 'Vereinigte Staaten von Amerika', 'États-Unis', 'Estados Unidos', 'アメリカ合衆国', 'Verenigde Staten'])
+    expect(country.names).to eq(['United States', 'Murica', 'Vereinigte Staaten von Amerika', 'États-Unis', 'Estados Unidos', 'アメリカ合衆国', 'Verenigde Staten'])
   end
 
   it 'should return translations' do
@@ -84,8 +85,18 @@ describe ISO3166::Country do
   end
 
   it 'knows when a country does not require postal codes' do
-    ireland = ISO3166::Country.search('IE')
-    expect(ireland.postal_code).to eq(false)
+    antarctica = ISO3166::Country.search('AQ')
+    expect(antarctica.postal_code).to eq(false)
+  end
+
+  it 'knows about the country postal code format' do
+    expect(country.postal_code_format).to_not be_nil
+
+    regex = Regexp.new(country.postal_code_format)
+    expect(regex).to match("12345-6789")
+
+    antarctica = ISO3166::Country.search('AQ')
+    expect(antarctica.postal_code_format).to be_nil
   end
 
   it 'should return region' do
@@ -242,6 +253,26 @@ describe ISO3166::Country do
     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
+      expect(subdivisions).to be_an(Array)
+      expect(subdivisions.first[0]).to be_a(String)
+      expect(subdivisions.size).to eq(27)
+      expect(subdivisions.first[0]).to eq('Alexandria')
+    end
+
+    it 'should return an alphabetized list of subdivision names translated to current locale with codes' do
+      ISO3166.configuration.locales = [:es, :de, :en]
+
+      subdivisions = ISO3166::Country.search('EG').subdivision_names_with_codes(:es)
+      expect(subdivisions).to be_an(Array)
+      expect(subdivisions.first[0]).to be_a(String)
+      expect(subdivisions.size).to eq(27)
+      expect(subdivisions.first[0]).to eq('Al Iskandariyah')
+    end
+  end
+
   describe 'valid?' do
     it 'should return true if country is valid' do
       expect(ISO3166::Country.new('US')).to be_valid
@@ -301,7 +332,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('Afghanistan')
+      expect(countries.first).to eq('Aruba')
       # 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)
@@ -311,7 +342,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('Afghanistan')
+      expect(countries.first).to eq('Aruba')
       expect(countries.size).to eq(NUM_OF_COUNTRIES)
     end
   end
@@ -376,14 +407,31 @@ describe ISO3166::Country do
       countries = ISO3166::Country.new(:de).translation('xxx')
       expect(countries).to be_nil
     end
+
+    context 'should return variant locales' do
+      it 'should return different value for Chinese variants' do
+        ISO3166.configuration.locales = [:'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')
+        expect([name_cn, name_hk, name_tw].uniq.size).to eql 3
+      end
+
+      it 'should return different value for Portuguese variants' do
+        ISO3166.configuration.locales = [: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
+      end
+    end
   end
 
   describe 'translations' 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('AF')
-      expect(countries.first).to eq(%w(AF Afghanistan))
+      expect(countries.first[0]).to eq('AW')
+      expect(countries.first).to eq(%w(AW Aruba))
       # 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)
@@ -392,8 +440,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('AF')
-      expect(countries.first).to eq(%w(AF Afghanistan))
+      expect(countries.first[0]).to eq('AW')
+      expect(countries.first).to eq(%w(AW Aruba))
       expect(countries.size).to eq(NUM_OF_COUNTRIES)
     end
   end
@@ -481,6 +529,19 @@ describe ISO3166::Country do
       expect(spain_data).to be_a Hash
       expect(spain_data.keys).to eq(['ES'])
     end
+
+    it 'performs reasonably' do
+      start = Time.now
+      250.times do
+        lookup = ['ZM', 'ZMB', 'Zambia', 'US', 'USA', 'United States'].sample
+        case lookup.length
+        when 2 then ISO3166::Country.find_all_by(:alpha2, lookup)
+        when 3 then ISO3166::Country.find_all_by(:alpha3, lookup)
+        else ISO3166::Country.find_all_by(:name, lookup)
+        end
+      end
+      expect(Time.now - start).to be < 1
+    end
   end
 
   describe 'hash finder methods' do
@@ -498,6 +559,31 @@ describe ISO3166::Country do
       end
     end
 
+    context "when search name with comma in 'name'" do
+      subject { ISO3166::Country.find_by_name(country_name) }
+
+      context 'with Republic of Korea' do
+        let(:country_name) { 'Korea, Republic of' }
+        it 'should return' do
+          expect(subject.first).to eq('KR')
+        end
+      end
+
+      context 'with Bolivia' do
+        let(:country_name) { 'Bolivia, Plurinational State of' }
+        it 'should return' do
+          expect(subject.first).to eq('BO')
+        end
+      end
+
+      context 'with Bonaire' do
+        let(:country_name) { 'Bonaire, Sint Eustatius and Saba' }
+        it 'should return' do
+          expect(subject.first).to eq('BQ')
+        end
+      end
+    end
+
     context 'when search lowercase multibyte name found' do
       subject { ISO3166::Country.find_country_by_name('россия') }
 
@@ -576,6 +662,15 @@ describe ISO3166::Country do
       end
     end
 
+    context 'when the search term contains comma' do
+      let(:korea) { ISO3166::Country.find_country_by_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|