countries 2.0.0.rc → 2.0.0

data/lib/countries/data/countries/ZM.yaml

@@ -30,12 +30,19 @@ ZM:
   languages_spoken:
   - en
   geo:
-    latitude: 15 00 S
+    latitude: -13.133897
     latitude_dec: "-13.458845138549805"
-    longitude: 30 00 E
+    longitude: 27.849332
     longitude_dec: '27.788097381591797'
-    max_latitude: '5'
-    max_longitude: '39.283333'
-    min_latitude: "-18.05"
-    min_longitude: '22'
+    max_latitude: -8.203284
+    max_longitude: 33.7090305
+    min_latitude: -18.0767539
+    min_longitude: 21.9993509
+    bounds:
+      northeast:
+        lat: -8.203284
+        lng: 33.7090305
+      southwest:
+        lat: -18.0767539
+        lng: 21.9993509
   currency_code: ZMW

data/lib/countries/data/countries/ZW.yaml

@@ -37,12 +37,19 @@ ZW:
   - sn
   - nd
   geo:
-    latitude: 20 00 S
+    latitude: -19.015438
     latitude_dec: "-19.000280380249023"
-    longitude: 30 00 E
+    longitude: 29.154857
     longitude_dec: '29.86876106262207'
-    max_latitude: "-15.6"
-    max_longitude: '33.05'
-    min_latitude: "-22.316667"
-    min_longitude: '25.333333'
-  currency_code: ZWD
+    max_latitude: -15.6107883
+    max_longitude: 33.068236
+    min_latitude: -22.4223538
+    min_longitude: 25.237368
+    bounds:
+      northeast:
+        lat: -15.6107883
+        lng: 33.068236
+      southwest:
+        lat: -22.4223538
+        lng: 25.237368
+  currency_code: USD

data/lib/countries/data/translation_corrections.yaml

@@ -20,4 +20,7 @@ ar:
   SO: "الصومال‎"
   SY: "سوريا"
 zh:
-  KH: '柬埔寨'
+  KH: '柬埔寨'
+ar:
+  BQ: "بونير، سينت أوستاتيوس وسابا"
+  CW: "كوراساو" 

data/lib/countries/iso3166.rb

@@ -6,6 +6,7 @@ require 'countries/kwarg_struct'
 require 'countries/configuration'
 require 'countries/data'
 require 'countries/structure'
+require 'countries/translations'
 require 'countries/country/class_methods'
 require 'countries/country/emoji'
 require 'countries/country'

data/lib/countries/kwarg_struct.rb

@@ -2,10 +2,10 @@ module ISO3166
   class KwargStruct < Struct
     # Override the initialize to handle hashes of named parameters
     def initialize(*args)
-      opts = args.last.is_a?(Hash) ? args.pop : Hash.new
+      opts = args.last.is_a?(Hash) ? args.pop : {}
       super(*args)
       opts.each_pair do |k, v|
-        self.send "#{k}=", v
+        send "#{k}=", v
       end
     end
   end

data/lib/countries/mongoid.rb

@@ -1,31 +1,31 @@
-module ISO3166; end
-
-class ISO3166::Country
-  def mongoize
-    ISO3166::Country.mongoize(self)
-  end
+module ISO3166
+  class Country
+    def mongoize
+      ISO3166::Country.mongoize(self)
+    end
 
-  class << self
-    def mongoize(country)
-      if country.is_a?(self) && !country.data.nil?
-        country.alpha2
-      elsif send(:valid_alpha2?, country)
-        new(country).alpha2
+    class << self
+      def mongoize(country)
+        if country.is_a?(self) && !country.data.nil?
+          country.alpha2
+        elsif send(:valid_alpha2?, country)
+          new(country).alpha2
+        end
       end
-    end
 
-    def demongoize(alpha2)
-      new(alpha2)
-    end
+      def demongoize(alpha2)
+        new(alpha2)
+      end
 
-    def evolve(country)
-      mongoize(country)
-    end
+      def evolve(country)
+        mongoize(country)
+      end
 
-    private
+      private
 
-    def valid_alpha2?(country)
-      country.is_a?(String) && !ISO3166::Country.new(country).nil?
+      def valid_alpha2?(country)
+        country.is_a?(String) && !ISO3166::Country.new(country).nil?
+      end
     end
   end
 end

data/lib/countries/setup.rb

@@ -6,7 +6,7 @@ module ISO3166
   class Setup
     # <b>DEPRECATED:</b> Please use <tt>Data.codes</tt> instead.
     def codes
-      warn "[DEPRECATION] `Setup.codes` is deprecated.  Please use `Data.codes` instead."
+      warn '[DEPRECATION] `Setup.codes` is deprecated.  Please use `Data.codes` instead.'
       Data.codes
     end
 

data/lib/countries/structure.rb

@@ -2,62 +2,71 @@
 #
 module ISO3166
   DEFAULT_COUNTRY_HASH = {
-    "address_format" => nil,
-    "alpha2" => nil,
-    "alpha3" => nil,
-    "continent" => nil,
-    "country_code" => nil,
-    "currency_code" => nil,
-    "gec" => nil,
-    "geo" => {
-      "latitude" => nil,
-      "latitude_dec" => nil,
-      "longitude" => nil,
-      "longitude_dec" => nil,
-      "max_latitude" => nil,
-      "max_longitude" => nil,
-      "min_latitude" => nil,
-      "min_longitude" => nil,
+    'address_format' => nil,
+    'alpha2' => nil,
+    'alpha3' => nil,
+    'continent' => nil,
+    'country_code' => nil,
+    'currency_code' => nil,
+    'gec' => nil,
+    'geo' => {
+      'latitude' => nil,
+      'latitude_dec' => nil,
+      'longitude' => nil,
+      'longitude_dec' => nil,
+      'max_latitude' => nil,
+      'max_longitude' => nil,
+      'min_latitude' => nil,
+      'min_longitude' => nil,
+      'bounds' => {
+        'northeast' => {
+          'lat' => nil,
+          'lng' => nil
+        },
+        'southwest' => {
+          'lat' => nil,
+          'lng' => nil
+        }
+      }
     },
-    "international_prefix" => nil,
-    "ioc" => nil,
-    "name" => nil,
-    "national_destination_code_lengths" => [],
-    "national_number_lengths" => [],
-    "national_prefix" => nil,
-    "nationality" => nil,
-    "number" => nil,
-    "languages_official" => [],
-    "languages_spoken" => [],
-    "translations" => {},
-    "postal_code" => nil,
-    "region" => nil,
-    "unofficial_names" => [],
-    "subregion" => nil,
-    "un_locode" => nil,
-    "vat_rates" => {
-      "standard" => nil,
-      "reduced" => [ nil, nil ],
-      "super_reduced" => nil,
-      "parking" => nil
+    'international_prefix' => nil,
+    'ioc' => nil,
+    'name' => nil,
+    'national_destination_code_lengths' => [],
+    'national_number_lengths' => [],
+    'national_prefix' => nil,
+    'nationality' => nil,
+    'number' => nil,
+    'languages_official' => [],
+    'languages_spoken' => [],
+    'translations' => {},
+    'postal_code' => nil,
+    'region' => nil,
+    'unofficial_names' => [],
+    'subregion' => nil,
+    'un_locode' => nil,
+    'vat_rates' => {
+      'standard' => nil,
+      'reduced' => [nil, nil],
+      'super_reduced' => nil,
+      'parking' => nil
     },
-    "world_region" => nil
-  }
+    'world_region' => nil
+  }.freeze
 
   DEFAULT_SUBDIVISION_HASH = {
     'name' => nil,
     'unofficial_names' => [],
     'translations' => {},
-    "geo" => {
-      "latitude" => nil,
-      "latitude_dec" => nil,
-      "longitude" => nil,
-      "longitude_dec" => nil,
-      "max_latitude" => nil,
-      "max_longitude" => nil,
-      "min_latitude" => nil,
-      "min_longitude" => nil,
+    'geo' => {
+      'latitude' => nil,
+      'latitude_dec' => nil,
+      'longitude' => nil,
+      'longitude_dec' => nil,
+      'max_latitude' => nil,
+      'max_longitude' => nil,
+      'min_latitude' => nil,
+      'min_longitude' => nil
     }
-  }
-
+  }.freeze
 end

data/lib/countries/tasks/geocoding.rake

@@ -0,0 +1,94 @@
+require 'geocoder'
+require 'retryable'
+# raise on geocoding errors such as query limit exceeded
+Geocoder.configure(always_raise: :all)
+# Try to geocode a given query, on exceptions it retries up to 3 times then gives up.
+# @param [String] query string to geocode
+# @return [Hash] first valid result or nil
+def geocode(query)
+  Retryable.retryable(tries: 3, sleep: ->(n) { 2**n }) do
+    Geocoder.search(query).first
+  end
+rescue => e
+  warn "Attempts exceeded for query #{query}, last error was #{e.message}"
+  nil
+end
+
+def load_country_yaml(alpha2)
+  YAML.load_file(File.join(ISO3166_ROOT_PATH, 'lib', 'countries', 'data', 'countries', "#{alpha2}.yaml"))
+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 }
+end
+
+def country_codes
+  @country_codes ||= Dir['lib/countries/data/countries/*.yaml'].map { |x| File.basename(x, File.extname(x)) }.uniq
+end
+
+namespace :geocode do
+  desc 'Retrieve and store subdivisions coordinates'
+  task :fetch_countries do
+    require 'countries'
+    # Iterate over countries
+    ISO3166::Country.all.each do |country|
+      code = country.alpha2
+      # Load unmutated yaml file.
+      data = load_country_yaml(country.alpha2)
+
+      next unless (result = geocode(country.name))
+
+      geometry = result.geometry
+
+      # Extract center point data
+      if geometry['location']
+        data[code]['geo']['latitude'] = geometry['location']['lat']
+        data[code]['geo']['longitude'] = geometry['location']['lng']
+      end
+
+      # 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']
+      data[code]['geo']['max_latitude'] = geometry['bounds']['northeast']['lat']
+      data[code]['geo']['max_longitude'] = geometry['bounds']['northeast']['lng']
+
+      # Persist
+      save_country_yaml(code, data)
+    end
+  end
+
+  desc 'Retrieve and store subdivisions coordinates'
+  task :fetch_subdivisions do
+    require '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|
+        location = "#{data['name']}, #{c.name}"
+
+        # Handle special geocoding cases where Google defaults to well known
+        # cities, instead of the states.
+        if c.alpha2 == 'US' && %w(NY WA OK).include?(code)
+          location = "#{data['name']} State, United States"
+        end
+
+        next unless (result = geocode(location))
+        geometry = result.geometry
+        if geometry['location']
+          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 }
+    end
+  end
+end

data/lib/countries/translations.rb

@@ -0,0 +1,12 @@
+module ISO3166
+  # Extend the hash class to allow locale lookup fall back behavior
+  #
+  # ex:
+  # if a country has translations for pt, and the user looks up `pt-br` fallback
+  # to `pt` to prevent from showing nil values
+  class Translations < Hash
+    def [](locale)
+      super(locale) || super(locale.sub(/-.*/, ''))
+    end
+  end
+end

data/lib/countries/version.rb

@@ -1,3 +1,3 @@
 module Countries
-  VERSION = '2.0.0.rc'
+  VERSION = '2.0.0'.freeze
 end

data/spec/country_spec.rb

@@ -1,7 +1,7 @@
 # encoding: utf-8
 
 require 'spec_helper'
-
+NUM_OF_COUNTRIES = 249
 describe ISO3166::Country do
   let(:country) { ISO3166::Country.search('US') }
 
@@ -28,11 +28,11 @@ describe ISO3166::Country do
   end
 
   it 'should return 3166 name' do
-    expect(country.name).to eq('United States')
+    expect(country.name).to eq('United States of America')
   end
 
   it 'should return alternate names' do
-    expect(country.names).to eq(['United States of America', 'Vereinigte Staaten von Amerika', 'États-Unis', 'Estados Unidos', 'アメリカ合衆国', 'Verenigde Staten'])
+    expect(country.names).to eq(['United States', 'Vereinigte Staaten von Amerika', 'États-Unis', 'Estados Unidos', 'アメリカ合衆国', 'Verenigde Staten'])
   end
 
   it 'should return translations' do
@@ -41,11 +41,15 @@ describe ISO3166::Country do
   end
 
   it 'should return latitude' do
-    expect(country.latitude).to eq('38 00 N')
+    expect(country.latitude).to eq(37.09024)
   end
 
   it 'should return longitude' do
-    expect(country.longitude).to eq('97 00 W')
+    expect(country.longitude).to eq(-95.712891)
+  end
+
+  it 'should return bounds' do
+    expect(country.bounds['northeast']['lat']).to eq(71.3867745)
   end
 
   it 'should return the decimal Latitude' do
@@ -109,6 +113,55 @@ describe ISO3166::Country do
     end
   end
 
+  context 'with Brazil' do
+    context 'with pt-BR translation' do
+      before do
+        ISO3166::Data.register(
+          alpha2: 'BR2',
+          name: 'Brazil',
+          languages_official: %w(pt-BR),
+          translations: {
+            'pt-BR' => 'Translation for pt-BR',
+            'pt' => 'Translation for pt'
+          }
+        )
+      end
+
+      let(:country) { ISO3166::Country.search('BR2') }
+
+      it 'should return its local name based on its language' do
+        expect(country.local_names).to match_array(['Translation for pt-BR'])
+      end
+
+      after do
+        ISO3166::Data.unregister('BR2')
+      end
+    end
+
+    context 'without pt-BR translation' do
+      before do
+        ISO3166::Data.register(
+          alpha2: 'BR2',
+          name: 'Brazil',
+          languages_official: %w(pt-BR),
+          translations: {
+            'pt' => 'Translation for pt'
+          }
+        )
+      end
+
+      let(:country) { ISO3166::Country.search('BR2') }
+
+      it 'should return its local name based on its language' do
+        expect(country.local_names).to match_array(['Translation for pt'])
+      end
+
+      after do
+        ISO3166::Data.unregister('BR2')
+      end
+    end
+  end
+
   it 'should return ioc code' do
     expect(country.ioc).to eq('USA')
   end
@@ -166,11 +219,11 @@ describe ISO3166::Country do
     end
 
     it 'should have a name' do
-      expect(virginia.name).to eq("Virginia")
+      expect(virginia.name).to eq('Virginia')
     end
 
     it 'should behave like a hash' do
-      expect(virginia["name"]).to eq("Virginia")
+      expect(virginia['name']).to eq('Virginia')
     end
   end
 
@@ -216,7 +269,7 @@ describe ISO3166::Country do
       countries = ISO3166::Country.all
       expect(countries).to be_an(Array)
       expect(countries.first).to be_an(ISO3166::Country)
-      expect(countries.size).to eq(250)
+      expect(countries.size).to eq(NUM_OF_COUNTRIES)
     end
 
     it 'should allow to customize each country representation passing a block to the method' do
@@ -224,7 +277,7 @@ describe ISO3166::Country do
       expect(countries).to be_an(Array)
       expect(countries.first).to be_an(Array)
       expect(countries.first.size).to eq(3)
-      expect(countries.size).to eq(250)
+      expect(countries.size).to eq(NUM_OF_COUNTRIES)
     end
   end
 
@@ -236,7 +289,7 @@ describe ISO3166::Country do
       expect(countries.first).to eq('Afghanistan')
       # 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(249)
+      expect(countries.size).to eq(NUM_OF_COUNTRIES)
     end
 
     it 'should return an alphabetized list of all country names in English if no locale is passed' do
@@ -244,7 +297,7 @@ describe ISO3166::Country do
       expect(countries).to be_an(Array)
       expect(countries.first).to be_a(String)
       expect(countries.first).to eq('Afghanistan')
-      expect(countries.size).to eq(249)
+      expect(countries.size).to eq(NUM_OF_COUNTRIES)
     end
   end
 
@@ -255,7 +308,7 @@ describe ISO3166::Country do
       expect(countries).to be_an(Array)
       expect(countries.first[0]).to be_a(String)
       expect(countries.first[0]).to eq('Afghanistan')
-      expect(countries.size).to eq(250)
+      expect(countries.size).to eq(NUM_OF_COUNTRIES)
     end
 
     it 'should return an alphabetized list of all country names translated to current locale with ISOCODE alpha2' do
@@ -265,7 +318,7 @@ describe ISO3166::Country do
       expect(countries).to be_an(Array)
       expect(countries.first[0]).to be_a(String)
       expect(countries.first[0]).to eq('Afganistán')
-      expect(countries.size).to eq(250)
+      expect(countries.size).to eq(NUM_OF_COUNTRIES)
     end
   end
 
@@ -297,7 +350,7 @@ describe ISO3166::Country do
       expect(countries.first).to eq(%w(AF Afghanistan))
       # 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(249)
+      expect(countries.size).to eq(NUM_OF_COUNTRIES)
     end
 
     it 'should return an hash of all country names in English if no locale is passed' do
@@ -305,7 +358,7 @@ describe ISO3166::Country do
       expect(countries).to be_an(Hash)
       expect(countries.first[0]).to eq('AF')
       expect(countries.first).to eq(%w(AF Afghanistan))
-      expect(countries.size).to eq(249)
+      expect(countries.size).to eq(NUM_OF_COUNTRIES)
     end
   end
 
@@ -346,7 +399,7 @@ describe ISO3166::Country do
   describe 'codes' do
     it 'returns a hash with the data of the country' do
       expect(ISO3166::Country.codes).to be_a Array
-      expect(ISO3166::Country.codes.size).to eq(250)
+      expect(ISO3166::Country.codes.size).to eq(NUM_OF_COUNTRIES)
     end
   end
 
@@ -409,28 +462,28 @@ describe ISO3166::Country do
       end
     end
 
-    context "when search lowercase multibyte name found" do
-      subject { ISO3166::Country.find_country_by_name("россия") }
+    context 'when search lowercase multibyte name found' do
+      subject { ISO3166::Country.find_country_by_name('россия') }
 
-      it "should be a country instance" do
+      it 'should be a country instance' do
         expect(subject).to be_a(ISO3166::Country)
         expect(subject.alpha2).to eq('RU')
       end
     end
 
-    context "when search lowercase multibyte name found" do
+    context 'when search lowercase multibyte name found' do
       subject { ISO3166::Country.find_country_by_name(/россия/) }
 
-      it "should be a country instance" do
+      it 'should be a country instance' do
         expect(subject).to be_a(ISO3166::Country)
         expect(subject.alpha2).to eq('RU')
       end
     end
 
-    context "when accents are not used" do
-      subject { ISO3166::Country.find_country_by_name("emirats Arabes Unis") }
+    context 'when accents are not used' do
+      subject { ISO3166::Country.find_country_by_name('emirats Arabes Unis') }
 
-      it "should be a country instance" do
+      it 'should be a country instance' do
         expect(subject).to be_a(ISO3166::Country)
         expect(subject.alpha2).to eq('AE')
       end
@@ -501,6 +554,22 @@ describe ISO3166::Country do
       end
     end
 
+    context 'regression test for #388' do
+      let(:no_country) { ISO3166::Country.find_country_by_translated_names(nil) }
+
+      it 'should be a country instance' do
+        expect(no_country).to_not be_a(ISO3166::Country)
+        expect(no_country).to eq nil
+      end
+    end
+
+    context 'when attempting to search by translations hash' do
+      let(:uk) { ISO3166::Country.find_country_by_translations({}) }
+
+      it 'should be a country instance' do
+        expect { uk }.to raise_error(RuntimeError)
+      end
+    end
     context 'when search name not found' do
       let(:bogus) { ISO3166::Country.find_country_by_name('Does not exist') }
 
@@ -644,7 +713,7 @@ describe ISO3166::Country do
     end
 
     it 'should return nil if the country does not have a GEC code' do
-      expect(ISO3166::Country.new('AN').gec).to eql nil
+      expect(ISO3166::Country.new('UM').gec).to eql nil
     end
   end
 
@@ -690,7 +759,7 @@ describe ISO3166::Country do
 
   describe 'Added country names to search by' do
     it 'should return country code for Democratic Republic of the Congo' do
-      expect(ISO3166::Country.find_country_by_name('Democratic Republic of the Congo').alpha2).to eq 'CG'
+      expect(ISO3166::Country.find_country_by_name('Democratic Republic of the Congo').alpha2).to eq 'CD'
     end
     it 'should return country code for Ivory Coast' do
       expect(ISO3166::Country.find_country_by_name('Ivory Coast').alpha2).to eq 'CI'
@@ -717,9 +786,9 @@ describe ISO3166::Country do
     end
   end
 
-  describe 'Emjoi' do
-    it 'has an emjoi flag' do
-      expect(country.emoji_flag).to eq "🇺🇸"
+  describe 'Emoji' do
+    it 'has an emoji flag' do
+      expect(country.emoji_flag).to eq '🇺🇸'
     end
   end
 end