countries 0.10.0 → 0.11.1

data/lib/data/subdivisions/YE.yaml

@@ -3,83 +3,83 @@ AB:
   name: Abyan
   names: Abyan
 AD:
-  name: ʿAdan
+  name: "ʿAdan"
   names:
-    - Adan
-    - ʿAdan
-    - Aden
-    - Aden
-    - Adén
+  - Adan
+  - "ʿAdan"
+  - Aden
+  - Aden
+  - Adén
 AM:
   name: "'Amran"
   names: "'Amran"
 BA:
-  name: "Al Bay?a'"
+  name: Al Bay?a'
   names:
-    - "Al Baida"
+  - Al Baida
 DA:
-  name: "Ad¸ D¸ali'"
-  names: "Ad¸ D¸ali'"
+  name: Ad¸ D¸ali'
+  names: Ad¸ D¸ali'
 DH:
   name: Dhamar
   names:
-    - Dhamar
-    - Dhomar
-    - Đomar
+  - Dhamar
+  - Dhomar
+  - "Đomar"
 HD:
   name: Hadramawt
   names:
-    - Hadramout
+  - Hadramout
 HJ:
   name: Hajjah
   names: Hajjah
 HU:
-  name: "Al ?udaydah"
+  name: Al ?udaydah
   names:
-    - Hodeida
-    - Hodeidah
-    - Hodeïah
-    - H̨udaydah
-    - al-Hudaydah
+  - Hodeida
+  - Hodeidah
+  - Hodeïah
+  - H̨udaydah
+  - al-Hudaydah
 IB:
   name: Ibb
   names: Ibb
 JA:
-  name: "Al Jawf"
-  names: "Al Jawf"
+  name: Al Jawf
+  names: Al Jawf
 LA:
   name: La?ij
   names:
-    - Lahej
-    - Lahj
+  - Lahej
+  - Lahj
 MA:
   name: Ma'rib
   names:
-    - Marab
-    - Mareb
+  - Marab
+  - Mareb
 MR:
-  name: "Al Mahrah"
-  names: "Al Mahrah"
+  name: Al Mahrah
+  names: Al Mahrah
 MW:
-  name: "Al Mahwit"
-  names: "Al Mahwit"
+  name: Al Mahwit
+  names: Al Mahwit
 SD:
   name: Sa`dah
   names:
-    - Saʿadah
+  - Saʿadah
 SH:
   name: Shabwah
   names:
-    - Shabwah
+  - Shabwah
 SN:
   name: Sanʿā
   names:
-    - Sana
-    - Sanaa
-    - Sanaʿa
-    - "Sanaʿa City"
-    - Sanʿaʿ
+  - Sana
+  - Sanaa
+  - Sanaʿa
+  - Sanaʿa City
+  - Sanʿaʿ
 TA:
   name: Taʿizz
   names:
-    - Taiz
+  - Taiz

data/lib/data/subdivisions/ZA.yaml

@@ -1,27 +1,27 @@
 ---
 EC:
-  name: "Eastern Cape"
+  name: Eastern Cape
   names:
-    - "Oos Kaap"
+  - Oos Kaap
 FS:
-  name: "Free State"
+  name: Free State
   names:
-    - Foreistata
-    - Vrystaat
+  - Foreistata
+  - Vrystaat
 GT:
   name: Gauteng
   names:
-    - Pretoria-Witwatersrand-Vereeniging
+  - Pretoria-Witwatersrand-Vereeniging
 LP:
   name: Limpopo
   names: Limpopo
 MP:
   name: Mpumalanga
   names:
-    - eMpumalanga
+  - eMpumalanga
 NC:
-  name: "Northern Cape"
-  names: "Northern Cape"
+  name: Northern Cape
+  names: Northern Cape
 NL:
   name: Kwazulu-Natal
   names: Kwazulu-Natal
@@ -29,6 +29,6 @@ NW:
   name: North-West
   names: North-West
 WC:
-  name: "Western Cape"
+  name: Western Cape
   names:
-    - "Wes Kaap"
+  - Wes Kaap

data/lib/data/subdivisions/ZM.yaml

@@ -1,30 +1,23 @@
 ---
-? "01"
-:
+'01':
   name: Western
   names: Western
-? "02"
-:
+'02':
   name: Central
   names: Central
-? "03"
-:
+'03':
   name: Eastern
   names: Eastern
-? "04"
-:
+'04':
   name: Luapula
   names: Luapula
-? "05"
-:
+'05':
   name: Northern
   names: Northern
-? "06"
-:
+'06':
   name: North-Western
   names: North-Western
-? "07"
-:
+'07':
   name: Southern
   names: Southern
 08:

data/lib/data/subdivisions/ZW.yaml

@@ -9,23 +9,23 @@ MA:
   name: Manicaland
   names: Manicaland
 MC:
-  name: "Mashonaland Central"
-  names: "Mashonaland Central"
+  name: Mashonaland Central
+  names: Mashonaland Central
 ME:
-  name: "Mashonaland East"
-  names: "Mashonaland East"
+  name: Mashonaland East
+  names: Mashonaland East
 MI:
   name: Midlands
   names: Midlands
 MN:
-  name: "Matabeleland North"
-  names: "Matabeleland North"
+  name: Matabeleland North
+  names: Matabeleland North
 MS:
-  name: "Matabeleland South"
-  names: "Matabeleland South"
+  name: Matabeleland South
+  names: Matabeleland South
 MV:
   name: Masvingo
   names: Masvingo
 MW:
-  name: "Mashonaland West"
-  names: "Mashonaland West"
+  name: Mashonaland West
+  names: Mashonaland West

data/lib/iso3166.rb

@@ -1,8 +1,9 @@
 require 'yaml'
 require 'iso4217'
+require 'i18n_data'
 
 require 'countries/country'
 
 if defined?(ActionView::Helpers::FormOptionsHelper)
-  ActionView::Helpers::FormOptionsHelper::COUNTRIES = ISO3166::Country::Names.map{ |(name,alpha2)| [name.html_safe,alpha2] }
+  ActionView::Helpers::FormOptionsHelper::COUNTRIES = ISO3166::Country::Names.map { |(name, alpha2)| [name.html_safe, alpha2] }
 end

data/spec/country_spec.rb

@@ -8,77 +8,85 @@ describe ISO3166::Country do
 
   it 'allows to create a country object from a symbol representation of the alpha2 code' do
     country = described_class.new(:us)
-    country.data.should_not be_nil
+    expect(country.data).not_to be_nil
   end
 
   it 'allows to create a country object from a lowercase alpha2 code' do
-    country = described_class.new("us")
-    country.data.should_not be_nil
+    country = described_class.new('us')
+    expect(country.data).not_to be_nil
   end
 
   it 'should return 3166 number' do
-    country.number.should == '840'
+    expect(country.number).to eq('840')
   end
 
   it 'should return 3166 alpha2 code' do
-    country.alpha2.should == 'US'
+    expect(country.alpha2).to eq('US')
   end
 
   it 'should return 3166 alpha3 code' do
-    country.alpha3.should == 'USA'
+    expect(country.alpha3).to eq('USA')
   end
 
   it 'should return 3166 name' do
-    country.name.should == 'United States'
+    expect(country.name).to eq('United States')
   end
 
   it 'should return alternate names' do
-    country.names.should == ["United States of America", "Vereinigte Staaten von Amerika", "États-Unis", "Estados Unidos", "アメリカ合衆国", "Verenigde Staten"]
+    expect(country.names).to eq(['United States of America', 'Vereinigte Staaten von Amerika', 'États-Unis', 'Estados Unidos', 'アメリカ合衆国', 'Verenigde Staten'])
   end
 
   it 'should return translations' do
-    country.translations.should be
-    country.translations["en"].should == "United States of America"
+    expect(country.translations).to be
+    expect(country.translations['en']).to eq('United States')
   end
 
   it 'should return latitude' do
-    country.latitude.should == '38 00 N'
+    expect(country.latitude).to eq('38 00 N')
   end
 
   it 'should return longitude' do
-    country.longitude.should == '97 00 W'
+    expect(country.longitude).to eq('97 00 W')
   end
 
-  it "should return continent" do
-    country.continent.should == "North America"
+  it 'should return the decimal Latitude' do
+    expect(country.latitude_dec).to eq('39.44325637817383')
+  end
+
+  it 'should return the decimal Longitude' do
+    expect(country.longitude_dec).to eq('-98.95733642578125')
+  end
+
+  it 'should return continent' do
+    expect(country.continent).to eq('North America')
   end
 
   it 'knows about whether or not the country uses postal codes' do
-    country.zip.should be_true
+    expect(country.zip).to be_truthy
   end
 
   it 'knows when a country does not require postal codes' do
     ireland = ISO3166::Country.search('IE')
-    ireland.postal_code.should == false
+    expect(ireland.postal_code).to eq(false)
   end
 
   it 'should return region' do
-    country.region.should == 'Americas'
+    expect(country.region).to eq('Americas')
   end
 
   it 'should return subregion' do
-    country.subregion.should == 'Northern America'
+    expect(country.subregion).to eq('Northern America')
   end
 
   it 'should return world region' do
-    country.world_region.should == 'AMER'
+    expect(country.world_region).to eq('AMER')
   end
 
   context 'with Turkey' do
     let(:country) { ISO3166::Country.search('TR') }
 
     it 'should indicate EMEA as the world region' do
-      country.world_region.should == 'EMEA'
+      expect(country.world_region).to eq('EMEA')
     end
   end
 
@@ -86,336 +94,415 @@ describe ISO3166::Country do
     let(:country) { ISO3166::Country.search('JP') }
 
     it 'should indicate APAC as the world region' do
-      country.world_region.should == 'APAC'
+      expect(country.world_region).to eq('APAC')
     end
   end
 
   it 'should return ioc code' do
-    country.ioc.should == 'USA'
+    expect(country.ioc).to eq('USA')
   end
 
   it 'should return UN/LOCODE' do
-    country.un_locode.should == 'US'
+    expect(country.un_locode).to eq('US')
   end
 
   it 'should be identical to itself' do
-    country.should == ISO3166::Country.search('US')
+    expect(country).to eq(ISO3166::Country.search('US'))
   end
 
   it 'should return language' do
-    country.languages[0].should == 'en'
+    expect(country.languages[0]).to eq('en')
   end
 
   describe 'e164' do
     it 'should return country_code' do
-      country.country_code.should == '1'
+      expect(country.country_code).to eq('1')
     end
 
     it 'should return national_destination_code_lengths' do
-      country.national_destination_code_lengths.should == [3]
+      expect(country.national_destination_code_lengths).to eq([3])
     end
 
     it 'should return national_number_lengths' do
-      country.national_number_lengths.should == [10]
+      expect(country.national_number_lengths).to eq([10])
     end
 
     it 'should return international_prefix' do
-      country.international_prefix.should == '011'
+      expect(country.international_prefix).to eq('011')
     end
 
     it 'should return national_prefix' do
-      country.national_prefix.should == '1'
+      expect(country.national_prefix).to eq('1')
     end
   end
 
   describe 'subdivisions' do
     it 'should return an empty hash for a country with no ISO3166-2' do
-      ISO3166::Country.search('VA').subdivisions.should have(0).subdivisions
+      expect(ISO3166::Country.search('VA').subdivisions.size).to eq(0)
     end
 
     it 'should return a hash with all sub divisions' do
-      country.subdivisions.should have(60).states
+      expect(country.subdivisions.size).to eq(60)
     end
 
     it 'should be available through states' do
-      country.states.should have(60).states
+      expect(country.states.size).to eq(60)
     end
   end
 
   describe 'valid?' do
     it 'should return true if country is valid' do
-      ISO3166::Country.new('US').should be_valid
+      expect(ISO3166::Country.new('US')).to be_valid
     end
 
     it 'should return false if country is invalid' do
-      ISO3166::Country.new({}).should_not be_valid
+      expect(ISO3166::Country.new({})).not_to be_valid
     end
   end
 
   describe 'new' do
     it 'should return new country object when a valid alpha2 string is passed' do
-      ISO3166::Country.new('US').should be_a(ISO3166::Country)
+      expect(ISO3166::Country.new('US')).to be_a(ISO3166::Country)
     end
 
     it 'should return nil when an invalid alpha2 string is passed' do
-      ISO3166::Country.new('fubar').should be_nil
+      expect(ISO3166::Country.new('fubar')).to be_nil
     end
 
     it 'should return new country object when a valid alpha2 symbol is passed' do
-      ISO3166::Country.new(:us).should be_a(ISO3166::Country)
+      expect(ISO3166::Country.new(:us)).to be_a(ISO3166::Country)
     end
 
     it 'should return nil when an invalid alpha2 symbol is passed' do
-      ISO3166::Country.new(:fubar).should be_nil
+      expect(ISO3166::Country.new(:fubar)).to be_nil
     end
   end
 
   describe 'all' do
     it 'should return an arry list of all countries' do
       countries = ISO3166::Country.all
-      countries.should be_an(Array)
-      countries.first.should be_an(Array)
-      countries.should have(250).countries
+      expect(countries).to be_an(Array)
+      expect(countries.first).to be_an(Array)
+      expect(countries.size).to eq(250)
     end
 
-    it "should allow to customize each country representation passing a block to the method" do
-      countries = ISO3166::Country.all { |country, data| [data['name'], country, data['country_code'] ] }
-      countries.should be_an(Array)
-      countries.first.should be_an(Array)
-      countries.first.should have(3).fields
-      countries.should have(250).countries
+    it 'should allow to customize each country representation passing a block to the method' do
+      countries = ISO3166::Country.all { |country, data| [data['name'], country, data['country_code']] }
+      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)
     end
   end
 
   describe 'all_translated' do
     it 'should return an alphabetized list of all country names translated to the selected locale' do
       countries = ISO3166::Country.all_translated('fr')
-      countries.should be_an(Array)
-      countries.first.should be_a(String)
-      countries.first.should eq('Afghanistan')
+      expect(countries).to be_an(Array)
+      expect(countries.first).to be_a(String)
+      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
-      countries.should have(249).countries
+      expect(countries.size).to eq(249)
     end
 
     it 'should return an alphabetized list of all country names in English if no locale is passed' do
       countries = ISO3166::Country.all_translated
-      countries.should be_an(Array)
-      countries.first.should be_a(String)
-      countries.first.should eq('Afghanistan')
-      countries.should have(250).countries
+      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)
+    end
+  end
+
+  describe 'translation' do
+    it 'should return the localized name for a country to the selected locale' do
+      countries = ISO3166::Country.new(:de).translation('de')
+      expect(countries).to be_an(String)
+      expect(countries).to eq('Deutschland')
+    end
+
+    it 'should return the localized name for a country in English' do
+      countries = ISO3166::Country.new(:de).translation
+      expect(countries).to be_an(String)
+      expect(countries).to eq('Germany')
+    end
+
+    it 'should return nil when a translation is not found' do
+      countries = ISO3166::Country.new(:de).translation('xxx')
+      expect(countries).to be_nil
+    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))
+      # 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)
+    end
+
+    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.size).to eq(249)
     end
   end
 
   describe 'countries' do
     it 'should be the same as all' do
-      ISO3166::Country.countries.should == ISO3166::Country.all
+      expect(ISO3166::Country.countries).to eq(ISO3166::Country.all)
     end
   end
 
   describe 'search' do
     it 'should return new country object when a valid alpha2 string is passed' do
-      ISO3166::Country.search('US').should be_a(ISO3166::Country)
+      expect(ISO3166::Country.search('US')).to be_a(ISO3166::Country)
     end
 
     it 'should return nil when an invalid alpha2 string is passed' do
-      ISO3166::Country.search('fubar').should be_nil
+      expect(ISO3166::Country.search('fubar')).to be_nil
     end
 
     it 'should return new country object when a valid alpha2 symbol is passed' do
-      ISO3166::Country.search(:us).should be_a(ISO3166::Country)
+      expect(ISO3166::Country.search(:us)).to be_a(ISO3166::Country)
     end
 
     it 'should return nil when an invalid alpha2 symbol is passed' do
-      ISO3166::Country.search(:fubar).should be_nil
+      expect(ISO3166::Country.search(:fubar)).to be_nil
     end
   end
 
   describe 'currency' do
     it 'should return an instance of Currency' do
-      country.currency.should be_a(ISO4217::Currency)
+      expect(country.currency).to be_a(ISO4217::Currency)
     end
 
     it 'should allow access to symbol' do
-      country.currency[:symbol].should == '$'
+      expect(country.currency[:symbol]).to eq('$')
     end
   end
 
-  describe "Country class" do
+  describe 'Country class' do
     context "when loaded via 'iso3166' existance" do
       subject { defined?(Country) }
 
-      it { should be_false }
+      it { is_expected.to be_falsey }
     end
 
     context "when loaded via 'countries'" do
       before { require 'countries' }
 
-      describe "existance" do
+      describe 'existance' do
         subject { defined?(Country) }
 
-        it { should be_true }
+        it { is_expected.to be_truthy }
       end
 
-      describe "superclass" do
+      describe 'superclass' do
         subject { Country.superclass }
 
-        it { should == ISO3166::Country }
+        it { is_expected.to eq(ISO3166::Country) }
       end
 
       describe 'to_s' do
         it 'should return the country name' do
-          Country.new('GB').to_s.should == 'United Kingdom'
+          expect(Country.new('GB').to_s).to eq('United Kingdom')
         end
       end
     end
   end
 
   describe 'find_all_by' do
-    context "when searchead attribute equals the given value" do
-      let(:spain_data) { ISO3166::Country.find_all_by('alpha2', "ES") }
+    context 'when searchead attribute equals the given value' do
+      let(:spain_data) { ISO3166::Country.find_all_by('alpha2', 'ES') }
 
-      it "returns a hash with the data of the country" do
-        spain_data.should be_a Hash
-        spain_data.should have(1).keys
+      it 'returns a hash with the data of the country' do
+        expect(spain_data).to be_a Hash
+        expect(spain_data.keys.size).to eq(1)
       end
     end
 
-    context "when searchead attribute is list and one of its elements equals the given value" do
-      let(:spain_data) { ISO3166::Country.find_all_by('languages', "en") }
+    context 'when searchead attribute is list and one of its elements equals the given value' do
+      let(:spain_data) { ISO3166::Country.find_all_by('languages', 'en') }
 
-      it "returns a hash with the data of the country" do
-        spain_data.should be_a Hash
-        spain_data.size.should > 1
+      it 'returns a hash with the data of the country' do
+        expect(spain_data).to be_a Hash
+        expect(spain_data.size).to be > 1
       end
     end
 
-    it "also finds results if the given values is not upcased/downcased properly" do
-      spain_data = ISO3166::Country.find_all_by('alpha2', "es")
-      spain_data.should be_a Hash
-      spain_data.should have(1).keys
+    it 'also finds results if the given values is not upcased/downcased properly' do
+      spain_data = ISO3166::Country.find_all_by('alpha2', 'es')
+      expect(spain_data).to be_a Hash
+      expect(spain_data.keys.size).to eq(1)
     end
 
-    it "also finds results if the attribute is given as a symbol" do
-      spain_data = ISO3166::Country.find_all_by(:alpha2, "ES")
-      spain_data.should be_a Hash
-      spain_data.should have(1).keys
+    it 'also finds results if the attribute is given as a symbol' do
+      spain_data = ISO3166::Country.find_all_by(:alpha2, 'ES')
+      expect(spain_data).to be_a Hash
+      expect(spain_data.keys.size).to eq(1)
     end
 
-    it "casts the given value to a string to perform the search" do
+    it 'casts the given value to a string to perform the search' do
       spain_data = ISO3166::Country.find_all_by(:country_code, 34)
-      spain_data.should be_a Hash
-      spain_data.keys.should == ['ES']
+      expect(spain_data).to be_a Hash
+      expect(spain_data.keys).to eq(['ES'])
     end
 
-    it "also performs searches with regexps and forces it to ignore case" do
+    it 'also performs searches with regexps and forces it to ignore case' do
       spain_data = ISO3166::Country.find_all_by(:names, /Españ/)
-      spain_data.should be_a Hash
-      spain_data.keys.should == ['ES']
+      expect(spain_data).to be_a Hash
+      expect(spain_data.keys).to eq(['ES'])
     end
   end
 
-  describe "hash finder methods" do
+  describe 'hash finder methods' do
     context "when search name in 'name'" do
-      subject { ISO3166::Country.find_by_name("Poland") }
-
-      its(:first) { should == "PL" }
+      subject { ISO3166::Country.find_by_name('Poland') }
+      it 'should return' do
+        expect(subject.first).to eq('PL')
+      end
     end
 
     context "when search lowercase name in 'name'" do
-      subject { ISO3166::Country.find_by_name("poland") }
-
-      its(:first) { should == "PL" }
+      subject { ISO3166::Country.find_by_name('poland') }
+      it 'should return' do
+        expect(subject.first).to eq('PL')
+      end
     end
 
     context "when search name in 'names'" do
-      subject { ISO3166::Country.find_by_name("Polonia") }
-
-      its(:first) { should == "PL" }
+      subject { ISO3166::Country.find_by_name('Polonia') }
+      it 'should return' do
+        expect(subject.first).to eq('PL')
+      end
     end
 
-    context "when finding by invalid attribute" do
-      it "should raise an error" do
-        lambda { ISO3166::Country.find_by_invalid('invalid') }.should raise_error
+    context 'when finding by invalid attribute' do
+      it 'should raise an error' do
+        expect { ISO3166::Country.find_by_invalid('invalid') }.to raise_error
       end
     end
 
-    context "when using find_all method" do
+    context 'when using find_all method' do
       let(:list) { ISO3166::Country.find_all_by_currency('USD') }
 
-      it "should be an Array of Arrays" do
-        list.should be_a(Array)
-        list.first.should be_a(Array)
+      it 'should be an Array of Arrays' do
+        expect(list).to be_a(Array)
+        expect(list.first).to be_a(Array)
       end
     end
 
-    context "when using find_by method" do
+    context 'when using find_by method' do
       subject { ISO3166::Country.find_by_alpha3('CAN') }
-
-      its(:length) { should == 2 }
-      its(:first) { should be_a(String) }
-      its(:last) { should be_a(Hash) }
+      it 'should return' do
+        expect(subject.length).to eq 2
+        expect(subject.first).to be_a(String)
+        expect(subject.last).to be_a(Hash)
+      end
     end
   end
 
-  describe "country finder methods" do
-    context "when search name found" do
-      let(:uk) { ISO3166::Country.find_country_by_name("United Kingdom") }
+  describe 'country finder methods' do
+    context 'when search name found' do
+      let(:uk) { ISO3166::Country.find_country_by_name('United Kingdom') }
 
-      it "should be a country instance" do
-        uk.should be_a(ISO3166::Country)
-        uk.alpha2.should == "GB"
+      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_name("united kingdom") }
+    context 'when search lowercase name found' do
+      let(:uk) { ISO3166::Country.find_country_by_name('united kingdom') }
 
-      it "should be a country instance" do
-        uk.should be_a(ISO3166::Country)
-        uk.alpha2.should == "GB"
+      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 name not found" do
-      let(:bogus) { ISO3166::Country.find_country_by_name("Does not exist") }
+    context 'when search translation found' do
+      let(:uk) { ISO3166::Country.find_country_by_name('Velika Britanija') }
 
-      it "should be a country instance" do
-        bogus.should == nil
+      it 'should be a country instance' do
+        expect(uk).to be_a(ISO3166::Country)
+        expect(uk.alpha2).to eq('GB')
       end
     end
 
-    context "when finding by invalid attribute" do
-      it "should raise an error" do
-        lambda { ISO3166::Country.find_country_by_invalid('invalid') }.should raise_error
+    context 'when search name not found' do
+      let(:bogus) { ISO3166::Country.find_country_by_name('Does not exist') }
+
+      it 'should be a country instance' do
+        expect(bogus).to eq(nil)
       end
     end
 
-    context "when using find_all method" do
+    # Spot checks #243
+    context 'when search name not found' do
+      let(:belgium) { ISO3166::Country.find_country_by_name('Belgium') }
+
+      it 'should be a country instance' do
+        expect(belgium.alpha2).to eq('BE')
+      end
+    end
+
+    # Spot checks #240
+    context 'when search name not found' do
+      let(:canada) { ISO3166::Country.find_country_by_name('Canada') }
+
+      it 'should be a country instance' do
+        expect(canada.alpha2).to eq('CA')
+      end
+    end
+
+    # Spot checks #241
+    context 'when search name not found' do
+      let(:iraq) { ISO3166::Country.find_country_by_name('Israel') }
+
+      it 'should be a country instance' do
+        expect(iraq.alpha2).to eq('IL')
+      end
+    end
+
+    context 'when finding by invalid attribute' do
+      it 'should raise an error' do
+        expect { ISO3166::Country.find_country_by_invalid('invalid') }.to raise_error
+      end
+    end
+
+    context 'when using find_all method' do
       let(:list) { ISO3166::Country.find_all_countries_by_currency('USD') }
 
-      it "should be an Array of Country objects" do
-        list.should be_a(Array)
-        list.first.should be_a(ISO3166::Country)
+      it 'should be an Array of Country objects' do
+        expect(list).to be_a(Array)
+        expect(list.first).to be_a(ISO3166::Country)
       end
     end
 
-    context "when using find_by method" do
+    context 'when using find_by method' do
       let(:country) { ISO3166::Country.find_country_by_alpha3('CAN') }
 
       it 'should be a single country object' do
-        country.should be_a(ISO3166::Country)
+        expect(country).to be_a(ISO3166::Country)
       end
     end
   end
 
-  describe "names in Data" do
-    it "should be unique (to allow .find_by_name work properly)" do
-      names = ISO3166::Country::Data.collect do |k,v|
-        [v["name"], v["names"]].flatten.uniq
+  describe 'names in Data' do
+    it 'should be unique (to allow .find_by_name work properly)' do
+      names = ISO3166::Country::Data.map do |_k, v|
+        [v['name'], v['names']].flatten.uniq
       end.flatten
 
-      names.size.should == names.uniq.size
+      expect(names.size).to eq(names.uniq.size)
     end
   end
 
@@ -423,7 +510,7 @@ describe ISO3166::Country do
     let(:norway) { ISO3166::Country.search('NO') }
 
     it 'should have a currency' do
-      norway.currency.should be_a(ISO4217::Currency)
+      expect(norway.currency).to be_a(ISO4217::Currency)
     end
   end
 
@@ -431,15 +518,15 @@ describe ISO3166::Country do
     let(:guernsey) { ISO3166::Country.search('GG') }
 
     it 'should have a currency' do
-      guernsey.currency.code.should == 'GBP'
+      expect(guernsey.currency.code).to eq('GBP')
     end
   end
 
   describe 'Languages' do
     let(:german_speaking_countries) { ISO3166::Country.find_all_countries_by_languages('de') }
 
-    it "should find countries by language" do
-      german_speaking_countries.size.should == 6
+    it 'should find countries by language' do
+      expect(german_speaking_countries.size).to eq(6)
     end
   end
 
@@ -447,17 +534,27 @@ describe ISO3166::Country do
     let(:netherlands) { ISO3166::Country.search('NL') }
 
     it 'should return false for countries without eu_member flag' do
-      country.in_eu?.should be_false
+      expect(country.in_eu?).to be_falsey
     end
 
     it 'should return true for countries with eu_member flag set to true' do
-      netherlands.in_eu?.should be_true
+      expect(netherlands.in_eu?).to be_truthy
+    end
+  end
+
+  describe 'gec' do
+    it 'should return the country\'s GEC code' do
+      expect(ISO3166::Country.new('NA').gec).to eql 'WA'
+    end
+
+    it 'should return nil if the country does not have a GEC code' do
+      expect(ISO3166::Country.new('AN').gec).to eql nil
     end
   end
 
   describe 'to_s' do
     it 'should return the country name' do
-      ISO3166::Country.new('GB').to_s.should == 'United Kingdom'
+      expect(ISO3166::Country.new('GB').to_s).to eq('United Kingdom')
     end
   end
 
@@ -465,18 +562,33 @@ describe ISO3166::Country do
     let(:belgium) { ISO3166::Country.search('BE') }
 
     it 'should not return a vat_rate for countries without federal VAT' do
-      country.vat_rates.should == nil
+      expect(country.vat_rates).to eq(nil)
     end
 
     it 'should contain all keys for vat_rates' do
-      belgium.vat_rates.should be_a(Hash)
-      belgium.vat_rates.keys.should == ["standard", "reduced", "super_reduced", "parking"]
+      expect(belgium.vat_rates).to be_a(Hash)
+      expect(belgium.vat_rates.keys).to eq(%w(standard reduced super_reduced parking))
     end
 
     it 'should return an array of reduced vat rates' do
-      belgium.vat_rates["reduced"].should be_an(Array)
-      belgium.vat_rates["reduced"].should == [6, 12]
+      expect(belgium.vat_rates['reduced']).to be_an(Array)
+      expect(belgium.vat_rates['reduced']).to eq([6, 12])
     end
   end
 
+  describe 'ISO3166::Country()' do
+    it 'should return same object if instance of ISO3166::Country given' do
+      expect(ISO3166::Country(country)).to eq country
+    end
+
+    it 'should return country if instance of String given' do
+      expect(ISO3166::Country('us')).to eq country
+    end
+
+    it 'should return country if not convertable input given' do
+      expect do
+        ISO3166::Country(42)
+      end.to raise_error(TypeError, "can't convert Fixnum into ISO3166::Country")
+    end
+  end
 end