country_select 7.0.0 → 8.0.3

data/lib/country_select/tag_helper.rb

@@ -1,12 +1,20 @@
+# frozen_string_literal: true
+
 module CountrySelect
-  class CountryNotFoundError < StandardError;end
+  class CountryNotFoundError < StandardError; end
+
   module TagHelper
+    unless respond_to?(:options_for_select)
+      include ActionView::Helpers::FormOptionsHelper
+      include ActionView::Helpers::Tags::SelectRenderer if defined?(ActionView::Helpers::Tags::SelectRenderer)
+    end
+
     def country_option_tags
       # In Rails 5.2+, `value` accepts no arguments and must also be called
       # with parens to avoid the local variable of the same name
       # https://github.com/rails/rails/pull/29791
       selected_option = @options.fetch(:selected) do
-        if self.method(:value).arity == 0
+        if self.method(:value).arity.zero?
           value()
         else
           value(@object)
@@ -14,26 +22,19 @@ module CountrySelect
       end
 
       option_tags_options = {
-        :selected => selected_option,
-        :disabled => @options[:disabled]
+        selected: selected_option,
+        disabled: @options[:disabled]
       }
 
       if priority_countries.present?
-        priority_countries_options = country_options_for(priority_countries, false)
-
-        option_tags = options_for_select(priority_countries_options, option_tags_options)
-        option_tags += html_safe_newline + options_for_select([priority_countries_divider], disabled: priority_countries_divider)
-
-        option_tags_options[:selected] = [option_tags_options[:selected]] unless option_tags_options[:selected].kind_of?(Array)
-        option_tags_options[:selected].delete_if{|selected| priority_countries_options.map(&:second).include?(selected)}
-
-        option_tags += html_safe_newline + options_for_select(country_options, option_tags_options)
+        options_for_select_with_priority_countries(country_options, option_tags_options)
       else
-        option_tags = options_for_select(country_options, option_tags_options)
+        options_for_select(country_options, option_tags_options)
       end
     end
 
     private
+
     def locale
       @options.fetch(:locale, ::CountrySelect::DEFAULTS[:locale])
     end
@@ -59,59 +60,63 @@ module CountrySelect
     end
 
     def country_options
-      country_options_for(all_country_codes, true)
-    end
-
-    def all_country_codes
       codes = ISO3166::Country.codes
 
       if only_country_codes.present?
-        codes & only_country_codes
-      elsif except_country_codes.present?
-        codes - except_country_codes
+        codes = only_country_codes & codes
+        sort = @options.fetch(:sort_provided, ::CountrySelect::DEFAULTS[:sort_provided])
       else
-        codes
+        codes -= except_country_codes if except_country_codes.present?
+        sort = true
       end
+
+      country_options_for(codes, sorted: sort)
     end
 
-    def country_options_for(country_codes, sorted=true)
+    def country_options_for(country_codes, sorted: true)
       I18n.with_locale(locale) do
-        country_list = country_codes.map do |code_or_name|
-          if country = ISO3166::Country.new(code_or_name)
-            code = country.alpha2
-          elsif country = ISO3166::Country.find_country_by_any_name(code_or_name)
-            code = country.alpha2
-          end
-
-          unless country.present?
-            msg = "Could not find Country with string '#{code_or_name}'"
-            raise CountryNotFoundError.new(msg)
-          end
-
-          formatted_country = ::CountrySelect::FORMATS[format].call(country)
-
-          if formatted_country.is_a?(Array)
-            formatted_country
-          else
-            [formatted_country, code]
-          end
+        country_list = country_codes.map { |code_or_name| get_formatted_country(code_or_name) }
 
-        end
+        country_list.sort_by! { |name, _| [I18n.transliterate(name.to_s), name] } if sorted
+        country_list
+      end
+    end
 
-        if sorted
-          if country_list.respond_to?(:sort_alphabetical)
-            country_list.sort_alphabetical
-          else
-            country_list.sort
-          end
-        else
-          country_list
-        end
+    def options_for_select_with_priority_countries(country_options, tags_options)
+      sorted = @options.fetch(:sort_provided, ::CountrySelect::DEFAULTS[:sort_provided])
+      priority_countries_options = country_options_for(priority_countries, sorted: sorted)
+
+      option_tags = priority_options_for_select(priority_countries_options, tags_options)
+
+      tags_options[:selected] = Array(tags_options[:selected]).delete_if do |selected|
+        priority_countries_options.map(&:second).include?(selected)
       end
+
+      option_tags += "\n".html_safe + options_for_select(country_options, tags_options)
+
+      option_tags
     end
 
-    def html_safe_newline
-      "\n".html_safe
+    def priority_options_for_select(priority_countries_options, tags_options)
+      option_tags = options_for_select(priority_countries_options, tags_options)
+      option_tags += "\n".html_safe +
+                     options_for_select([priority_countries_divider], disabled: priority_countries_divider)
+    end
+
+    def get_formatted_country(code_or_name)
+      country = ISO3166::Country.new(code_or_name) ||
+                ISO3166::Country.find_country_by_any_name(code_or_name)
+
+      raise(CountryNotFoundError, "Could not find Country with string '#{code_or_name}'") unless country.present?
+
+      code = country.alpha2
+      formatted_country = ::CountrySelect::FORMATS[format].call(country)
+
+      if formatted_country.is_a?(Array)
+        formatted_country
+      else
+        [formatted_country, code]
+      end
     end
   end
 end

data/lib/country_select/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module CountrySelect
-  VERSION = '7.0.0'
+  VERSION = '8.0.3'
 end

data/lib/country_select.rb

@@ -1,7 +1,6 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
 require 'countries'
-require 'sort_alphabetical'
 
 require 'country_select/version'
 require 'country_select/defaults'

data/spec/country_select_spec.rb

@@ -1,11 +1,15 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
 require 'spec_helper'
 
 require 'action_view'
 require 'country_select'
 
-describe "CountrySelect" do
+class Walrus
+  attr_accessor :country_code
+end
+
+describe 'CountrySelect' do
   include ActionView::Helpers::TagHelper
   include ActionView::Helpers::FormOptionsHelper
 
@@ -15,10 +19,6 @@ describe "CountrySelect" do
     ISO3166.reset
   end
 
-  class Walrus
-    attr_accessor :country_code
-  end
-
   let(:walrus) { Walrus.new }
   let!(:template) { ActionView::Base.new(ActionView::LookupContext.new([]), {}, nil) }
 
@@ -26,17 +26,17 @@ describe "CountrySelect" do
     if defined?(ActionView::Helpers::Tags::Base)
       ActionView::Helpers::FormBuilder.new(:walrus, walrus, template, {})
     else
-      ActionView::Helpers::FormBuilder.new(:walrus, walrus, template, {}, Proc.new { })
+      ActionView::Helpers::FormBuilder.new(:walrus, walrus, template, {}, proc {})
     end
   end
 
   let(:select_tag) do
-    <<-EOS.chomp.strip
+    <<-HTML.chomp.strip
       <select id="walrus_country_code" name="walrus[country_code]">
-    EOS
+    HTML
   end
 
-  it "selects the value of country_code" do
+  it 'selects the value of country_code' do
     tag = options_for_select([['United States', 'US']], 'US')
 
     walrus.country_code = 'US'
@@ -44,8 +44,8 @@ describe "CountrySelect" do
     expect(t).to include(tag)
   end
 
-  it "uses the locale specified by I18n.locale" do
-    I18n.available_locales = [:en, :es]
+  it 'uses the locale specified by I18n.locale' do
+    I18n.available_locales = %i[en es]
     ISO3166.reset
 
     tag = options_for_select([['Estados Unidos', 'US']], 'US')
@@ -62,10 +62,10 @@ describe "CountrySelect" do
   end
 
   it 'falls back when given a country-specific locale' do
-    I18n.available_locales = [:en, :de, :'de-AT']
+    I18n.available_locales = %i[en de de-AT]
     ISO3166.reset
 
-    tag = options_for_select([['Deutschland', 'DE']], 'DE')
+    tag = options_for_select([%w[Deutschland DE]], 'DE')
 
     walrus.country_code = 'DE'
     original_locale = I18n.locale
@@ -78,76 +78,142 @@ describe "CountrySelect" do
     end
   end
 
-  it "accepts a locale option" do
+  it 'accepts a locale option' do
     I18n.available_locales = [:fr]
     ISO3166.reset
 
-    tag = options_for_select([['États-Unis', 'US']], 'US')
+    tag = options_for_select([%w[États-Unis US]], 'US')
 
     walrus.country_code = 'US'
     t = builder.country_select(:country_code, locale: :fr)
     expect(t).to include(tag)
   end
 
-  it "accepts priority countries" do
+  it 'accepts priority countries' do
+    tag = options_for_select(
+      [
+        ['Denmark', 'DK'],
+        ['Latvia', 'LV'],
+        ['United States', 'US'],
+        ['-' * 15, '-' * 15]
+      ],
+      selected: 'US',
+      disabled: '-' * 15
+    )
+
+    walrus.country_code = 'US'
+    t = builder.country_select(:country_code, priority_countries: %w[LV US DK])
+    expect(t).to include(tag)
+  end
+
+  it 'priority countries are sorted by name by default' do
+    tag = options_for_select(
+      [
+        ['Denmark', 'DK'],
+        ['Latvia', 'LV'],
+        ['United States', 'US'],
+        ['-' * 15, '-' * 15]
+      ],
+      selected: 'US',
+      disabled: '-' * 15
+    )
+
+    walrus.country_code = 'US'
+    t = builder.country_select(:country_code, priority_countries: %w[LV US DK])
+    expect(t).to include(tag)
+  end
+
+  it 'priority countries with `sort_provided: false` preserves the provided order' do
     tag = options_for_select(
       [
-        ['Latvia','LV'],
-        ['United States','US'],
+        ['Latvia', 'LV'],
+        ['United States', 'US'],
         ['Denmark', 'DK'],
-        ['-'*15,'-'*15]
+        ['-' * 15, '-' * 15]
       ],
       selected: 'US',
-      disabled: '-'*15
+      disabled: '-' * 15
     )
 
     walrus.country_code = 'US'
-    t = builder.country_select(:country_code, priority_countries: ['LV','US','DK'])
+    t = builder.country_select(:country_code, priority_countries: %w[LV US DK], sort_provided: false)
+    expect(t).to include(tag)
+  end
+
+  it 'priority countries with `sort_provided: false` still sorts the non-priority countries by name' do
+    tag = options_for_select(
+      [
+        ['Latvia', 'LV'],
+        ['United States', 'US'],
+        ['Denmark', 'DK'],
+        ['-' * 15, '-' * 15],
+        ['Afghanistan', 'AF']
+      ],
+      selected: 'AF',
+      disabled: '-' * 15
+    )
+
+    walrus.country_code = 'AF'
+    t = builder.country_select(:country_code, priority_countries: %w[LV US DK], sort_provided: false)
     expect(t).to include(tag)
   end
 
-  describe "when selected options is not an array" do
-    it "selects only the first matching option" do
-      tag = options_for_select([["United States", "US"],["Uruguay", "UY"]], "US")
+  describe 'when selected options is not an array' do
+    it 'selects only the first matching option' do
+      tag = options_for_select([['United States', 'US'], ['Uruguay', 'UY']], 'US')
       walrus.country_code = 'US'
-      t = builder.country_select(:country_code, priority_countries: ['LV','US'])
+      t = builder.country_select(:country_code, priority_countries: %w[LV US])
       expect(t).to_not include(tag)
     end
   end
 
-  describe "when selected options is an array" do
-    it "selects all options but only once" do
+  describe 'when selected options is an array' do
+    it 'selects all options but only once' do
       walrus.country_code = 'US'
-      t = builder.country_select(:country_code, {priority_countries: ['LV','US','ES'], selected: ['UY', 'US']}, multiple: true)
-      expect(t.scan(options_for_select([["United States", "US"]], "US")).length).to be(1)
-      expect(t.scan(options_for_select([["Uruguay", "UY"]], "UY")).length).to be(1)
+      t = builder.country_select(:country_code,
+                                 { priority_countries: %w[LV US ES], selected: %w[UY US] },
+                                 multiple: true)
+      expect(t.scan(options_for_select([['United States', 'US']], 'US')).length).to be(1)
+      expect(t.scan(options_for_select([%w[Uruguay UY]], 'UY')).length).to be(1)
     end
   end
 
-  it "displays only the chosen countries" do
-    options = [["Denmark", "DK"],["Germany", "DE"]]
+  it 'displays only the chosen countries' do
+    options = [%w[Denmark DK], %w[Germany DE]]
     tag = builder.select(:country_code, options)
     walrus.country_code = 'US'
-    t = builder.country_select(:country_code, only: ['DK','DE'])
+    t = builder.country_select(:country_code, only: %w[DK DE])
     expect(t).to eql(tag)
   end
 
-  it "discards some countries" do
-    tag = options_for_select([["United States", "US"]])
+  it 'discards some countries' do
+    tag = options_for_select([['United States', 'US']])
     walrus.country_code = 'DE'
     t = builder.country_select(:country_code, except: ['US'])
     expect(t).to_not include(tag)
   end
 
+  it 'countries provided in `only` are sorted by name by default' do
+    t = builder.country_select(:country_code, only: %w[PT DE AR])
+    order = t.scan(/value="(\w{2})"/).map { |o| o[0] }
+    expect(order).to eq(%w[AR DE PT])
+  end
+
+  it 'countries provided in `only` with `sort_provided` to false keeps the order of the provided countries' do
+    t = builder.country_select(:country_code, only: %w[PT DE AR], sort_provided: false)
+    order = t.scan(/value="(\w{2})"/).map { |o| o[0] }
+    expect(order).to eq(%w[PT DE AR])
+  end
+
   context "when there is a default 'except' configured" do
     around do |example|
-      old_value = ::CountrySelect::DEFAULTS[:except]
+      old_value = CountrySelect::DEFAULTS[:except]
       example.run
-      ::CountrySelect::DEFAULTS[:except] = old_value
+      CountrySelect::DEFAULTS[:except] = old_value
     end
 
-    it "discards countries when configured to" do
-      ::CountrySelect::DEFAULTS[:except] = ['US']
+    it 'discards countries when configured to' do
+      CountrySelect::DEFAULTS[:except] = ['US']
 
       tag = options_for_select([['United States', 'US']])
       walrus.country_code = 'DE'
@@ -156,51 +222,49 @@ describe "CountrySelect" do
     end
   end
 
-  context "using old 1.x syntax" do
-    it "accepts priority countries" do
+  context 'using old 1.x syntax' do
+    it 'accepts priority countries' do
       tag = options_for_select(
         [
-          ['Latvia','LV'],
-          ['United States','US'],
           ['Denmark', 'DK'],
-          ['-'*15,'-'*15]
+          ['Latvia', 'LV'],
+          ['United States', 'US'],
+          ['-' * 15, '-' * 15]
         ],
         selected: 'US',
-        disabled: '-'*15
+        disabled: '-' * 15
       )
 
       walrus.country_code = 'US'
-      t = builder.country_select(:country_code, ['LV','US','DK'])
+      t = builder.country_select(:country_code, %w[LV US DK])
       expect(t).to include(tag)
     end
 
-    it "selects only the first matching option" do
-      tag = options_for_select([["United States", "US"],["Uruguay", "UY"]], "US")
+    it 'selects only the first matching option' do
+      tag = options_for_select([['United States', 'US'], ['Uruguay', 'UY']], 'US')
       walrus.country_code = 'US'
-      t = builder.country_select(:country_code, ['LV','US'])
+      t = builder.country_select(:country_code, %w[LV US])
       expect(t).to_not include(tag)
     end
 
-    it "supports the country names as provided by default in Formtastic" do
-      tag = options_for_select([
-        ["Australia", "AU"],
-        ["Canada", "CA"],
-        ["United Kingdom", "GB"],
-        ["United States", "US"]
-      ])
-      country_names = ["Australia", "Canada", "United Kingdom", "United States"]
+    it 'supports the country names as provided by default in Formtastic' do
+      tag = options_for_select([['Australia', 'AU'],
+                                ['Canada', 'CA'],
+                                ['United Kingdom', 'GB'],
+                                ['United States', 'US']])
+      country_names = ['Australia', 'Canada', 'United Kingdom', 'United States']
       t = builder.country_select(:country_code, country_names)
       expect(t).to include(tag)
     end
 
-    it "raises an error when a country code or name is not found" do
+    it 'raises an error when a country code or name is not found' do
       country_names = [
-        "United States",
-        "Canada",
-        "United Kingdom",
-        "Mexico",
-        "Australia",
-        "Freedonia"
+        'United States',
+        'Canada',
+        'United Kingdom',
+        'Mexico',
+        'Australia',
+        'Freedonia'
       ]
       error_msg = "Could not find Country with string 'Freedonia'"
 
@@ -209,13 +273,13 @@ describe "CountrySelect" do
       end.to raise_error(CountrySelect::CountryNotFoundError, error_msg)
     end
 
-    it "supports the select prompt" do
+    it 'supports the select prompt' do
       tag = '<option value="">Select your country</option>'
       t = builder.country_select(:country_code, prompt: 'Select your country')
       expect(t).to include(tag)
     end
 
-    it "supports the include_blank option" do
+    it 'supports the include_blank option' do
       # Rails 6.1 more closely follows the HTML spec for
       # empty option tags.
       # https://github.com/rails/rails/pull/39808
@@ -230,31 +294,14 @@ describe "CountrySelect" do
   end
 
   it 'sorts unicode' do
-    tag = builder.country_select(:country_code, only: ['AX', 'AL', 'AF', 'ZW'])
+    tag = builder.country_select(:country_code, only: %w[AX AL AF ZW])
     order = tag.scan(/value="(\w{2})"/).map { |o| o[0] }
-    expect(order).to eq(['AF', 'AX', 'AL', 'ZW'])
-  end
-
-  context "without sort_alphabetical" do
-    before do
-      Enumerable.send(:alias_method, :_sort_alphabetical, :sort_alphabetical)
-      Enumerable.send(:remove_method, :sort_alphabetical)
-    end
-
-    after do
-      Enumerable.send(:alias_method, :sort_alphabetical, :_sort_alphabetical)
-    end
-
-    it 'falls back to regular sort' do
-      tag = builder.country_select(:country_code, only: ['AX', 'AL', 'AF', 'ZW'])
-      order = tag.scan(/value="(\w{2})"/).map { |o| o[0] }
-      expect(order).to eq(['AF', 'AL', 'ZW', 'AX'])
-    end
+    expect(order).to eq(%w[AF AX AL ZW])
   end
 
-  describe "custom formats" do
-    it "accepts a custom formatter" do
-      ::CountrySelect::FORMATS[:with_alpha2] = lambda do |country|
+  describe 'custom formats' do
+    it 'accepts a custom formatter' do
+      CountrySelect::FORMATS[:with_alpha2] = lambda do |country|
         "#{country.iso_short_name} (#{country.alpha2})"
       end
 
@@ -265,8 +312,8 @@ describe "CountrySelect" do
       expect(t).to include(tag)
     end
 
-    it "accepts an array for formatter" do
-      ::CountrySelect::FORMATS[:with_alpha3] = lambda do |country|
+    it 'accepts an array for formatter' do
+      CountrySelect::FORMATS[:with_alpha3] = lambda do |country|
         [country.iso_short_name, country.alpha3]
       end
 
@@ -276,8 +323,8 @@ describe "CountrySelect" do
       expect(t).to include(tag)
     end
 
-    it "accepts an array for formatter + custom formatter" do
-      ::CountrySelect::FORMATS[:with_alpha3] = lambda do |country|
+    it 'accepts an array for formatter + custom formatter' do
+      CountrySelect::FORMATS[:with_alpha3] = lambda do |country|
         ["#{country.iso_short_name} (#{country.alpha2})", country.alpha3]
       end
 
@@ -287,8 +334,8 @@ describe "CountrySelect" do
       expect(t).to include(tag)
     end
 
-    it "marks priority countries as selected only once" do
-      ::CountrySelect::FORMATS[:with_alpha3] = lambda do |country|
+    it 'marks priority countries as selected only once' do
+      CountrySelect::FORMATS[:with_alpha3] = lambda do |country|
         [country.iso_short_name, country.alpha3]
       end
 

data/spec/spec_helper.rb

@@ -1,4 +1,8 @@
+# frozen_string_literal: true
+
 require 'pry'
+require 'simplecov'
+SimpleCov.start
 
 # This file was generated by the `rspec --init` command. Conventionally, all
 # specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
@@ -55,11 +59,11 @@ RSpec.configure do |config|
   #   - http://myronmars.to/n/dev-blog/2012/06/rspecs-new-expectation-syntax
   #   - http://teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
   #   - http://myronmars.to/n/dev-blog/2014/05/notable-changes-in-rspec-3#new__config_option_to_disable_rspeccore_monkey_patching
-  #config.disable_monkey_patching!
+  # config.disable_monkey_patching!
 
   # This setting enables warnings. It's recommended, but in some cases may
   # be too noisy due to issues in dependencies.
-  #config.warnings = true
+  # config.warnings = true
 
   # Many RSpec users commonly either run the entire suite or an individual
   # file, and it's useful to allow more verbose output when running an
@@ -74,7 +78,7 @@ RSpec.configure do |config|
   # Print the 10 slowest examples and example groups at the
   # end of the spec run, to help surface which specs are running
   # particularly slow.
-  #config.profile_examples = 10
+  # config.profile_examples = 10
 
   # Run specs in random order to surface order dependencies. If you find an
   # order dependency and want to debug it, you can fix the order by providing