countries 1.2.2 → 4.2.3

data/spec/data_spec.rb

@@ -0,0 +1,181 @@
+# encoding: utf-8
+require 'spec_helper'
+require 'benchmark'
+
+describe ISO3166::Data do
+  it 'responds to call' do
+    data = ISO3166::Data.new('US').call
+    expect(data['translated_names']).to be_a Array
+  end
+
+  it 'can load selective locales' do
+    # ISO3166::Data.update_cache
+    ISO3166.configuration.locales = [:es, :de, :en]
+    data = ISO3166::Data.new('US').call
+    expect(data['translated_names'].size).to eq 3
+  end
+
+  it 'can load selective locales and reload efficiently' do
+    ISO3166.configuration.locales = [:es, :de, :en]
+    data = ISO3166::Data.new('US').call
+    expect(data['translations']).to eq('de' => 'Vereinigte Staaten', 'es' => 'Estados Unidos', 'en' => 'United States')
+    expect(data['translated_names'].sort).to eq ['Vereinigte Staaten', 'Estados Unidos', 'United States'].sort
+    ISO3166.configuration.locales = [:en]
+    data = ISO3166::Data.new('US').call
+    expect(data['translated_names'].size).to eq 1
+  end
+
+  describe '#codes' do
+    it 'returns an array' do
+      data = ISO3166::Data.codes
+      expect(data).to be_a Array
+      expect(data.size).to eq 249
+    end
+  end
+
+  it 'locales will load prior to return results' do
+    # require 'memory_profiler'
+    ISO3166.configuration.locales = [:es, :de, :en]
+    # report = MemoryProfiler.report do
+    ISO3166::Data.update_cache
+    # end
+
+    # report.pretty_print(to_file: 'tmp/memory/3_locales')
+    ISO3166::Data.update_cache
+
+    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]
+    end
+    # puts Benchmark.measure {ISO3166::Data.update_cache}
+
+    # report = MemoryProfiler.report do
+    ISO3166::Data.update_cache
+    # end
+
+    # report.pretty_print(to_file: 'tmp/memory/all_locales')
+
+    expect(ISO3166::Country.new('DE').translations.size).to eq 92
+
+    expect(ISO3166.configuration.loaded_locales.size).to eq 92
+  end
+
+  it 'locales will load prior and be cached' do
+    ISO3166.reset
+    ISO3166.configuration.locales = [:es, :de, :en]
+    expect(ISO3166::Data.send(:locales_to_load)).to eql(%w(es de en))
+    ISO3166::Data.update_cache
+    ISO3166.configuration.locales = [:es, :de, :en]
+    expect(ISO3166::Data.send(:locales_to_load)).to eql([])
+  end
+
+  it 'locales will load prior and be cached' do
+    ISO3166.reset
+    ISO3166.configuration.locales = [:es, :de, :en]
+    expect(ISO3166::Data.send(:locales_to_remove)).to eql([])
+    expect(ISO3166::Country.new('DE').translation('de')).to eq 'Deutschland'
+    ISO3166::Data.update_cache
+    ISO3166.configuration.locales = [:es, :en]
+    expect(ISO3166::Data.send(:locales_to_remove)).to eql(['de'])
+    expect(ISO3166::Country.new('DE').translation('de')).to eq nil
+  end
+
+  describe '#load_cache' do
+    it 'will return an empty hash for an unsupported locale' do
+      file_array = %w(locales unsupported.json)
+      expect(ISO3166::Data.send(:load_cache, file_array)).to eql({})
+    end
+
+    it 'will return json for a supported locale' do
+      file_array = %w(locales en.json)
+      expect(ISO3166::Data.send(:load_cache, file_array)).not_to be_empty
+    end
+  end
+
+  describe 'hotloading existing data' do
+    before do
+      ISO3166::Data.register(
+        alpha2: 'TW',
+        iso_short_name: 'NEW Taiwan',
+        subdivisions: {
+          CHA: {name: 'New Changhua'},
+          CYI: {name: 'New Municipality'}
+        },
+        translations: {
+          'en' => 'NEW Taiwan',
+          'de' => 'NEW Taiwan'
+        }
+      )
+    end
+
+    subject { ISO3166::Country.new('TW') }
+
+    it 'can be done' do
+      data = ISO3166::Data.new('TW').call
+      ISO3166.configuration.locales = [:es, :de, :de]
+      expect(data['iso_short_name']).to eq 'NEW Taiwan'
+      expect(subject.iso_short_name).to eq 'NEW Taiwan'
+      expect(subject.translations).to eq('en' => 'NEW Taiwan',
+                                         'de' => 'NEW Taiwan')
+      expect(subject.subdivisions).to eq('CHA' => ISO3166::Subdivision.new({name: 'New Changhua', code: 'CHA'}),
+                                         'CYI' => ISO3166::Subdivision.new({name: 'New Municipality', code: 'CYI'}))
+    end
+  end
+
+  describe 'hotloading data' do
+    before do
+      ISO3166::Data.register(
+        alpha2: 'LOL',
+        iso_short_name: 'Happy Country',
+        subdivisions: {
+          LOL1: {name: 'Happy sub1'},
+          LOL2: {name: 'Happy sub2'}
+        },
+        translations: {
+          'en' => 'Happy Country',
+          'de' => 'glückliches Land'
+        }
+      )
+    end
+
+    subject { ISO3166::Country.new('LOL') }
+
+    it 'can be done' do
+      data = ISO3166::Data.new('LOL').call
+      expect(data['iso_short_name']).to eq 'Happy Country'
+      expect(subject.iso_short_name).to eq 'Happy Country'
+      expect(subject.subdivisions).to eq('LOL1' => ISO3166::Subdivision.new({name: 'Happy sub1', code: 'LOL1'}),
+                                         'LOL2' => ISO3166::Subdivision.new({name: 'Happy sub2', code: 'LOL2'}))
+    end
+
+    it 'detect a stale cache' do
+      ISO3166::Data.register(alpha2: 'SAD', iso_short_name: 'Sad Country')
+      data = ISO3166::Data.new('SAD').call
+      expect(data['iso_short_name']).to eq 'Sad Country'
+      expect(ISO3166::Country.new('SAD').iso_short_name).to eq 'Sad Country'
+      ISO3166::Data.unregister('SAD')
+    end
+
+    it 'will not override custom translations' do
+      data = ISO3166::Data.new('LOL').call
+      expect(data['translations']).to eq('en' => 'Happy Country',
+                                         'de' => 'glückliches Land')
+      expect(subject.translations).to eq('en' => 'Happy Country',
+                                         'de' => 'glückliches Land')
+    end
+
+    it 'leaves remain countries intact after a hotload' do
+      data = ISO3166::Data.new('US').call
+      expect(data).to include('subregion')
+    end
+
+    it 'can be undone' do
+      ISO3166::Data.unregister('lol')
+      data = ISO3166::Data.new('LOL').call
+      expect(data).to eq nil
+    end
+
+    after do
+      ISO3166::Data.unregister('lol')
+    end
+  end
+end

data/spec/mongoid_spec.rb

@@ -1,6 +1,6 @@
 # encoding: utf-8
 
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+require 'spec_helper'
 require File.expand_path('../../lib/countries/mongoid', __FILE__)
 
 describe 'Mongoid support' do
@@ -24,7 +24,7 @@ describe 'Mongoid support' do
       end
 
       it 'should store nil given an invalid object' do
-        bad_types = [[], Time.now, {}, Date.today]
+        bad_types = [[], Time.now.utc, {}, Date.new(2029, 10, 1)]
         bad_types.each do |type|
           expect(ISO3166::Country.mongoize(type)).to eql nil
         end

data/spec/perf_spec.rb

@@ -0,0 +1,74 @@
+# encoding: utf-8
+require 'spec_helper'
+
+describe ISO3166::Data, perf: true, order: :defined do
+
+  ALL_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
+  ].freeze
+
+  def perf_report(_name)
+    require 'benchmark'
+    require 'memory_profiler'
+    require 'ruby-prof'
+    # profile the code
+    RubyProf.start
+
+    100.times do
+      yield if block_given?
+    end
+
+    result = RubyProf.stop
+
+    # print a flat profile to text
+    printer = RubyProf::FlatPrinter.new(result)
+    printer.print(STDOUT)
+  end
+
+  it 'responds to call' do
+    perf_report('translations') do
+      ISO3166.reset
+      data = ISO3166::Data.new('US').call
+      expect(data['translated_names']).to be_a Array
+    end
+  end
+
+  it 'locales will load prior to return results' do
+    ISO3166.configuration.locales = [:es, :de, :en]
+    report = MemoryProfiler.report do
+      ISO3166::Data.update_cache
+    end
+
+    report.pretty_print(to_file: 'tmp/memory/3_locales')
+    puts Benchmark.measure { ISO3166::Data.update_cache }
+
+    ISO3166.configure do |config|
+      config.locales = ALL_LOCALES
+    end
+    puts Benchmark.measure { ISO3166::Data.update_cache }
+
+    report = MemoryProfiler.report do
+      ISO3166::Data.update_cache
+    end
+
+    report.pretty_print(to_file: 'tmp/memory/all_locales')
+  end
+
+  it 'loades a specfic country quickly' do
+    codes = Dir['lib/countries/data/countries/*.yaml'].map { |x| File.basename(x, File.extname(x)) }.uniq
+    Benchmark.bmbm do |bm|
+      bm.report('find_by_alpha2') do
+        codes.map { |cc| ISO3166::Country.find_country_by_alpha2 cc }
+      end
+      bm.report('new') do
+        codes.map { |cc| ISO3166::Country.new cc }
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -1 +1,13 @@
 require 'countries'
+RSpec.configure do |config|
+  config.filter_run :focus
+  config.run_all_when_everything_filtered = true
+  config.filter_run_excluding perf: true
+  config.example_status_persistence_file_path = 'spec/examples.txt'
+
+  config.warnings = true
+
+  config.default_formatter = 'doc' if config.files_to_run.one?
+  # config.order = :random
+  # Kernel.srand config.seed
+end

data/spec/subdivision_spec.rb

@@ -0,0 +1,32 @@
+# coding: utf-8
+
+require 'spec_helper'
+
+describe ISO3166::Subdivision do
+  before do
+    ISO3166::Data.reset
+  end
+
+  let(:countries) { ISO3166::Country.all }
+  let(:available_types) { [Hash, NilClass] }
+
+  describe 'translations' do
+    it 'should be hash or nil' do
+      countries.each do |country|
+        country.subdivisions.each do |_, region|
+          expect(available_types).to include(region.translations.class)
+        end
+      end
+    end
+  end
+
+  describe 'state codes' do
+    it 'should all be strings' do
+      countries.each do |country|
+        expect(country.subdivisions.keys).to all(be_a(String)), \
+          "Expected #{country.alpha2.inspect} to have string subdivision" \
+          "codes but had #{country.subdivisions.keys.inspect}"
+      end
+    end
+  end
+end

data/spec/thread_safety_spec.rb

@@ -0,0 +1,46 @@
+describe 'Accessing ISO3166::Country instances data in multiple threads' do
+  before do
+    if Thread.respond_to?(:report_on_exception)
+      @report_on_exception_value = Thread.report_on_exception
+      Thread.report_on_exception = false
+    end
+
+    ISO3166::Data.reset
+  end
+
+  def create_countries_threaded
+    nthreads = 100
+    threads = []
+
+    alpha2_codes = ['us', 'es', 'nl', 'ca', 'de', 'fr', 'mx', 'ru', 'ch', 'jp']
+
+    nthreads.times do
+      threads << Thread.new do
+        alpha2_codes.each do |a2|
+          country = ISO3166::Country[a2]
+          # This will fail if data['translations'] has been
+          # left nil due to a race condition
+          country.translation
+        end
+      end
+    end
+    threads.map(&:join)
+  end
+
+  it "doesn't raise any exceptions when using a mutex" do
+    expect { create_countries_threaded }.to_not raise_error
+  end
+
+  it "raises NoMethodError when not using a mutex" do
+    allow(ISO3166::Data).to receive(:use_mutex?).and_return(false)
+
+    expect { create_countries_threaded }.to raise_error(NoMethodError)
+  end
+
+  after do
+    if Thread.respond_to?(:report_on_exception)
+      Thread.report_on_exception = @report_on_exception_value
+    end
+  end
+end
+

data/spec/timezone_spec.rb

@@ -0,0 +1,32 @@
+describe 'timezone Country class' do
+  context "when loaded via 'timezone'" do
+    require 'tzinfo'
+    describe 'existence' do
+      subject { defined?(TZInfo) }
+
+      it { is_expected.to be_truthy }
+    end
+
+    describe 'GB' do
+      subject { ISO3166::Country.new('GB') }
+      it 'should return the tzinfo country object' do
+        expect(subject.timezones).to be_a(TZInfo::Country)
+      end
+
+      it 'should return the tzinfo country object' do
+        expect(subject.timezones.zone_info).to be_a(Array)
+      end
+
+      it 'should return the tzinfo country object' do
+        expect(subject.timezones.zone_identifiers).to eq ['Europe/London']
+      end
+    end
+
+    describe 'US' do
+      subject { ISO3166::Country.new('US') }
+      it 'should return the tzinfo country object' do
+        expect(subject.timezones.zone_identifiers.size).to eq 29
+      end
+    end
+  end
+end