countries 5.7.0 → 5.7.1

data/spec/data_spec.rb

@@ -1,260 +0,0 @@
-# frozen_string_literal: true
-
-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 = %i[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 = %i[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
-
-  it 'only loads subdivision translations for the configured locales' do
-    ISO3166.configuration.locales = %i[en]
-    ISO3166::Data.reset
-    subdivisions = ISO3166::Data.subdivisions('US')
-    expect(subdivisions.values.first['translations'].keys).to eq(%w[en])
-    ISO3166.configuration.locales = %i[es de en]
-    ISO3166::Data.reset
-    subdivisions = ISO3166::Data.subdivisions('US')
-    expect(subdivisions.values.first['translations'].keys).to eq(%w[es de en])
-  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 = %i[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 = %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
-    # 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 = %i[es de en]
-    expect(ISO3166::Data.send(:locales_to_load)).to eql(%w[es de en])
-    ISO3166::Data.update_cache
-    ISO3166.configuration.locales = %i[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 = %i[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 = %i[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 = %i[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.keys).to eq(%w[CHA CYI])
-      expect(subject.subdivisions.values.map(&:name)).to eq(['New Changhua', 'New Municipality'])
-    end
-
-    after do
-      ISO3166.reset
-    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.keys).to eq(%w[LOL1 LOL2])
-      expect(subject.subdivisions.values.map(&:name)).to eq(['Happy sub1', 'Happy sub2'])
-    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.reset
-    end
-  end
-
-  describe 'data checks' do
-    context 'subdivision YAML files' do
-      it 'has a non-blank code for all subdivisions' do
-        Dir['lib/countries/data/subdivisions/*.yaml'].each do |file|
-          data = YAML.load_file(file)
-          expect(data.values.none? { |s| s['code'].nil? }).to be_truthy, "empty subdivision code in #{file}"
-        end
-      end
-
-      it 'has a non-blank, lowercase and snake_case type for all subdivisions' do
-        Dir['lib/countries/data/subdivisions/*.yaml'].each do |file|
-          data = YAML.load_file(file)
-          no_type = data.select { |_k, v| v['type'].nil? }
-          expect(no_type).to be_empty, "empty subdivision type in #{file} - #{no_type.keys}"
-          uppercase = data.select { |_k, v| v['type'] =~ /[A-Z]/ }
-          expect(uppercase).to be_empty, "uppercase characters in subdivision type in #{file} - #{uppercase.keys}"
-          spaces = data.select { |_k, v| v['type'] =~ /\s/ }
-          expect(spaces).to be_empty, "whitespace characters in subdivision type in #{file} - #{spaces.keys}"
-        end
-      end
-
-      it 'has a non-blank name for all subdivisions' do
-        Dir['lib/countries/data/subdivisions/*.yaml'].each do |file|
-          data = YAML.load_file(file)
-          expect(data.values.none? { |s| s['name'].nil? }).to be_truthy, "empty subdivision name in #{file}"
-        end
-      end
-    end
-
-    context 'cached country subdivision data' do
-      it 'has a non-blank code for all subdivisions' do
-        ISO3166::Country.all.each do |country|
-          expect(country.subdivisions.values.none? do |s|
-                   s['code'].nil?
-                 end).to be_truthy, "empty subdivision code in #{country}"
-        end
-      end
-
-      it 'has a non-blank name for all subdivisions' do
-        ISO3166::Country.all.each do |country|
-          expect(country.subdivisions.values.none? do |s|
-                   s['name'].nil?
-                 end).to be_truthy, "empty subdivision name in #{country}"
-        end
-      end
-    end
-
-    context 'names in Data' do
-      it 'should be unique (to allow .find_by_any_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
-  end
-end

data/spec/mongoid_spec.rb

@@ -1,61 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-require File.expand_path('../lib/countries/mongoid', __dir__)
-
-describe 'Mongoid support' do
-  let(:britain) { ISO3166::Country.new('GB') }
-  context 'instance methods' do
-    describe 'mongoize' do
-      it 'should delegate mongoization to the class method' do
-        expect(britain.mongoize).to eql ISO3166::Country.mongoize(britain)
-      end
-    end
-  end
-
-  context 'class methods' do
-    describe 'mongoize' do
-      it 'should store the alpha2 given a country object' do
-        expect(ISO3166::Country.mongoize(britain)).to eql britain.alpha2
-      end
-
-      it 'should store the alpha2 given a valid alpha2' do
-        expect(ISO3166::Country.mongoize('GB')).to eql britain.alpha2
-      end
-
-      it 'should store nil given an invalid object' do
-        bad_types = [[], Time.now.utc, {}, Date.new(2029, 10, 1)]
-        bad_types.each do |type|
-          expect(ISO3166::Country.mongoize(type)).to eql nil
-        end
-      end
-
-      it 'should store nil given an empty country object' do
-        expect(ISO3166::Country.mongoize(ISO3166::Country.new(''))).to eql nil
-      end
-
-      it 'should store nil given a bad alpha2' do
-        expect(ISO3166::Country.mongoize('bad_alpha_2')).to eql nil
-      end
-    end
-
-    describe 'demongoize' do
-      it 'should instantiate an equivalent object from stored alpha2 code' do
-        expect(ISO3166::Country.demongoize(britain.mongoize).data)
-          .to eql britain.data
-      end
-
-      it 'should be indifferent to storage by alpha2' do
-        expect(ISO3166::Country.demongoize(ISO3166::Country.mongoize('GB'))
-        .data).to eql britain.data
-      end
-    end
-
-    describe 'evolve' do
-      it 'should delegate to self.mongoize and return the mongoized object' do
-        expect(ISO3166::Country).to receive(:mongoize).with(britain)
-        ISO3166::Country.evolve(britain)
-      end
-    end
-  end
-end

data/spec/perf_spec.rb

@@ -1,74 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-ALL_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
-].freeze
-
-describe ISO3166::Data, perf: true, order: :defined do
-  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 = %i[es de en]
-    report = MemoryProfiler.report do
-      ISO3166::Data.update_cache
-    end
-
-    report.pretty_print(to_file: 'tmp/3_locales.txt')
-    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/all_locales.txt')
-  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,19 +0,0 @@
-# frozen_string_literal: true
-
-require 'countries'
-require 'debug'
-require 'simplecov'
-SimpleCov.start
-
-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

@@ -1,42 +0,0 @@
-# frozen_string_literal: true
-
-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
-
-  describe 'code_with_translations' do
-    before { ISO3166.configuration.locales = %i[en pt] }
-    it 'returns a hash' do
-      expect(ISO3166::Country.new('IT').subdivisions['NA'].code_with_translations).to eq({ 'NA' => { 'en' => 'Naples',
-                                                                                                     'pt' => 'Nápoles' } })
-    end
-  end
-end

data/spec/thread_safety_spec.rb

@@ -1,47 +0,0 @@
-# frozen_string_literal: true
-
-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 = %w[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

@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-
-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