country_select 1.2.0 → 4.0.0

data/lib/country_select/country_select_helper.rb

@@ -0,0 +1,38 @@
+module ActionView
+  module Helpers
+    class FormBuilder
+      def country_select(method, priority_or_options = {}, options = {}, html_options = {})
+        if Hash === priority_or_options
+          html_options = options
+          options = priority_or_options
+        else
+          options[:priority_countries] = priority_or_options
+        end
+
+        @template.country_select(@object_name, method, objectify_options(options), @default_options.merge(html_options))
+      end
+    end
+
+    module FormOptionsHelper
+      def country_select(object, method, options = {}, html_options = {})
+        Tags::CountrySelect.new(object, method, self, options, html_options).render
+      end
+    end
+
+    module Tags
+      class CountrySelect < Base
+        include ::CountrySelect::TagHelper
+
+        def initialize(object_name, method_name, template_object, options, html_options)
+          @html_options = html_options
+
+          super(object_name, method_name, template_object, options)
+        end
+
+        def render
+          select_content_tag(country_option_tags, @options, @html_options)
+        end
+      end
+    end
+  end
+end

data/lib/country_select/formats.rb

@@ -0,0 +1,7 @@
+module CountrySelect
+  FORMATS = {}
+
+  FORMATS[:default] = lambda do |country|
+    country.translations[I18n.locale.to_s] || country.name
+  end
+end

data/lib/country_select/rails3/country_select_helper.rb

@@ -0,0 +1,39 @@
+module ActionView
+  module Helpers
+    class FormBuilder
+      def country_select(method, priority_or_options = {}, options = {}, html_options = {})
+        if Hash === priority_or_options
+          html_options = options
+          options = priority_or_options
+        else
+          options[:priority_countries] = priority_or_options
+        end
+
+        @template.country_select(@object_name, method, objectify_options(options), @default_options.merge(html_options))
+      end
+    end
+
+    module FormOptionsHelper
+      def country_select(object, method, options = {}, html_options = {})
+        CountrySelect.new(object, method, self, options.delete(:object)).render(options, html_options)
+      end
+    end
+
+    class CountrySelect < InstanceTag
+      include ::CountrySelect::TagHelper
+
+      def render(options, html_options)
+        @options = options
+        @html_options = html_options
+
+        if self.respond_to?(:select_content_tag)
+          select_content_tag(country_option_tags, @options, @html_options)
+        else
+          html_options = @html_options.stringify_keys
+          add_default_name_and_id(html_options)
+          content_tag(:select, add_options(country_option_tags, options, value(object)), html_options)
+        end
+      end
+    end
+  end
+end

data/lib/country_select/tag_helper.rb

@@ -0,0 +1,118 @@
+module CountrySelect
+  class CountryNotFoundError < StandardError;end
+  module TagHelper
+    def country_option_tags
+      # In Rails 5.2+, `value` accepts no arguments and must also be called
+      # 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
+          value()
+        else
+          value(@object)
+        end
+      end
+
+      option_tags_options = {
+        :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)
+      else
+        option_tags = options_for_select(country_options, option_tags_options)
+      end
+    end
+
+    private
+    def locale
+      @options[:locale]
+    end
+
+    def priority_countries
+      @options[:priority_countries]
+    end
+
+    def priority_countries_divider
+      @options[:priority_countries_divider] || "-"*15
+    end
+
+    def only_country_codes
+      @options[:only]
+    end
+
+    def except_country_codes
+      @options[:except]
+    end
+
+    def format
+      @options[:format] || :default
+    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
+      else
+        codes
+      end
+    end
+
+    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_by_name(code_or_name)
+            code = country.first
+            country = ISO3166::Country.new(code)
+          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
+
+        end
+
+        if sorted
+          if country_list.respond_to?(:sort_alphabetical)
+            country_list.sort_alphabetical
+          else
+            country_list.sort
+          end
+        else
+          country_list
+        end
+      end
+    end
+
+    def html_safe_newline
+      "\n".html_safe
+    end
+  end
+end

data/lib/country_select/version.rb

@@ -1,3 +1,3 @@
 module CountrySelect
-  VERSION = "1.2.0"
+  VERSION = '4.0.0'
 end

data/lib/country_select_without_sort_alphabetical.rb

@@ -0,0 +1,13 @@
+# encoding: utf-8
+
+require 'countries'
+
+require 'country_select/version'
+require 'country_select/formats'
+require 'country_select/tag_helper'
+
+if defined?(ActionView::Helpers::Tags::Base)
+  require 'country_select/country_select_helper'
+else
+  require 'country_select/rails3/country_select_helper'
+end

data/spec/country_select_spec.rb

@@ -1,133 +1,261 @@
+# encoding: utf-8
+
 require 'spec_helper'
 
 require 'action_view'
 require 'country_select'
 
-module ActionView
-  module Helpers
+describe "CountrySelect" do
+  include ActionView::Helpers::TagHelper
+  include ActionView::Helpers::FormOptionsHelper
 
-    describe CountrySelect do
-      include TagHelper
+  before do
+    I18n.available_locales = [:en]
+    I18n.locale = :en
+    ISO3166.reset
+  end
 
-      class Walrus
-        attr_accessor :country_name
-      end
+  class Walrus
+    attr_accessor :country_code
+  end
 
-      let(:walrus) { Walrus.new }
+  let(:walrus) { Walrus.new }
+  let!(:template) { ActionView::Base.new }
 
-      let!(:template) { ActionView::Base.new }
+  let(:builder) do
+    if defined?(ActionView::Helpers::Tags::Base)
+      ActionView::Helpers::FormBuilder.new(:walrus, walrus, template, {})
+    else
+      ActionView::Helpers::FormBuilder.new(:walrus, walrus, template, {}, Proc.new { })
+    end
+  end
 
-      let(:select_tag) do
-        "<select id=\"walrus_country_name\" name=\"walrus[country_name]\">"
-      end
+  let(:select_tag) do
+    <<-EOS.chomp.strip
+      <select id="walrus_country_code" name="walrus[country_code]">
+    EOS
+  end
 
-      let(:selected_us_option) do
-        if defined?(Tags::Base)
-          content_tag(:option, 'United States', :selected => :selected, :value => "United States")
-        else
-          "<option value=\"United States\" selected=\"selected\">United States</option>"
-        end
-      end
+  it "selects the value of country_code" do
+    tag = options_for_select([['United States', 'US']], 'US')
+
+    walrus.country_code = 'US'
+    t = builder.country_select(:country_code)
+    expect(t).to include(tag)
+  end
+
+  it "uses the locale specified by I18n.locale" do
+    I18n.available_locales = [:en, :es]
+    ISO3166.reset
+
+    tag = options_for_select([['Estados Unidos', 'US']], 'US')
+
+    walrus.country_code = 'US'
+    original_locale = I18n.locale
+    begin
+      I18n.locale = :es
+      t = builder.country_select(:country_code)
+      expect(t).to include(tag)
+    ensure
+      I18n.locale = original_locale
+    end
+  end
+
+  it "accepts a locale option" do
+    I18n.available_locales = [:fr]
+    ISO3166.reset
+
+    tag = options_for_select([['É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
+    tag = options_for_select(
+      [
+        ['Latvia','LV'],
+        ['United States','US'],
+        ['Denmark', 'DK'],
+        ['-'*15,'-'*15]
+      ],
+      selected: 'US',
+      disabled: '-'*15
+    )
+
+    walrus.country_code = 'US'
+    t = builder.country_select(:country_code, priority_countries: ['LV','US','DK'])
+    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")
+      walrus.country_code = 'US'
+      t = builder.country_select(:country_code, priority_countries: ['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
+      tag = options_for_select([["United States", "US"],["Uruguay", "UY"],["Spain", "ES"]], "US")
+      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)
+    end
+  end
+
+  it "displays only the chosen countries" do
+    options = [["Denmark", "DK"],["Germany", "DE"]]
+    tag = builder.select(:country_code, options)
+    walrus.country_code = 'US'
+    t = builder.country_select(:country_code, only: ['DK','DE'])
+    expect(t).to eql(tag)
+  end
+
+  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
 
-      let(:selected_iso_us_option) do
-        if defined?(Tags::Base)
-          content_tag(:option, 'United States', :selected => :selected, :value => 'us')
-        else
-          "<option value=\"us\" selected=\"selected\">United States</option>"
-        end
+  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]
+        ],
+        selected: 'US',
+        disabled: '-'*15
+      )
+
+      walrus.country_code = 'US'
+      t = builder.country_select(:country_code, ['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")
+      walrus.country_code = 'US'
+      t = builder.country_select(:country_code, ['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"]
+      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
+      country_names = [
+        "United States",
+        "Canada",
+        "United Kingdom",
+        "Mexico",
+        "Australia",
+        "Freedonia"
+      ]
+      error_msg = "Could not find Country with string 'Freedonia'"
+
+      expect do
+        builder.country_select(:country_code, country_names)
+      end.to raise_error(CountrySelect::CountryNotFoundError, error_msg)
+    end
+
+    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
+      tag = '<option value=""></option>'
+      t = builder.country_select(:country_code, include_blank: true)
+      expect(t).to include(tag)
+    end
+  end
+
+  it 'sorts unicode' 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', '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
+  end
+
+  describe "custom formats" do
+    it "accepts a custom formatter" do
+      ::CountrySelect::FORMATS[:with_alpha2] = lambda do |country|
+        "#{country.name} (#{country.alpha2})"
       end
 
-      let(:builder) do
-        if defined?(Tags::Base)
-          FormBuilder.new(:walrus, walrus, template, {})
-        else
-          FormBuilder.new(:walrus, walrus, template, {}, Proc.new { })
-        end
+      tag = options_for_select([['United States of America (US)', 'US']], 'US')
+
+      walrus.country_code = 'US'
+      t = builder.country_select(:country_code, format: :with_alpha2)
+      expect(t).to include(tag)
+    end
+
+    it "accepts an array for formatter" do
+      ::CountrySelect::FORMATS[:with_alpha3] = lambda do |country|
+        [country.name, country.alpha3]
       end
 
-      context "iso codes disabled" do
-        describe "#country_select" do
-          let(:tag) { builder.country_select(:country_name) }
-
-          it "creates a select tag" do
-            tag.should include(select_tag)
-          end
-
-          it "creates option tags of the countries" do
-            ::CountrySelect::COUNTRIES.each do |code,name|
-              tag.should include(content_tag(:option, name, :value => name))
-            end
-          end
-
-          it "selects the value of country_name" do
-            walrus.country_name = 'United States'
-            t = builder.country_select(:country_name)
-            t.should include(selected_us_option)
-          end
-        end
-
-        describe "#priority_countries" do
-          let(:tag) { builder.country_select(:country_name, ['United States']) }
-
-          it "puts the countries at the top" do
-            tag.should include("#{select_tag}<option value=\"United States")
-          end
-
-          it "inserts a divider" do
-            tag.should include(">United States</option><option value=\"\" disabled=\"disabled\">-------------</option>")
-          end
-
-          it "does not mark two countries as selected" do
-            walrus.country_name = "United States"
-            str = <<-EOS.strip
-              </option>\n<option value="United States" selected="selected">United States</option>
-            EOS
-            tag.should_not include(str)
-          end
-        end
+      tag = options_for_select([['United States of America', 'USA']], 'USA')
+      walrus.country_code = 'USA'
+      t = builder.country_select(:country_code, format: :with_alpha3)
+      expect(t).to include(tag)
+    end
+
+    it "accepts an array for formatter + custom formatter" do
+      ::CountrySelect::FORMATS[:with_alpha3] = lambda do |country|
+        ["#{country.name} (#{country.alpha2})", country.alpha3]
       end
 
-      context "iso codes enabled" do
-        describe "#country_select" do
-          let(:tag) { builder.country_select(:country_name, nil, :iso_codes => true) }
-
-          it "creates a select tag" do
-            tag.should include(select_tag)
-          end
-
-          it "creates option tags of the countries" do
-            ::CountrySelect::COUNTRIES.each do |code,name|
-              tag.should include(content_tag(:option, name, :value => code))
-            end
-          end
-
-          it "selects the value of country_name" do
-            walrus.country_name = 'us'
-            t = builder.country_select(:country_name, nil, :iso_codes => true)
-            t.should include(selected_iso_us_option)
-          end
-        end
-
-        describe "#priority_countries" do
-          let(:tag) { builder.country_select(:country_name, ['us'], :iso_codes => true) }
-
-          it "puts the countries at the top" do
-            tag.should include("#{select_tag}<option value=\"us")
-          end
-
-          it "inserts a divider" do
-            tag.should include(">United States</option><option value=\"\" disabled=\"disabled\">-------------</option>")
-          end
-
-          it "does not mark two countries as selected" do
-            walrus.country_name = "us"
-            str = <<-EOS.strip
-              </option>\n<option value="us" selected="selected">United States</option>
-            EOS
-            tag.should_not include(str)
-          end
-        end
+      tag = options_for_select([['United States of America (US)', 'USA']], 'USA')
+      walrus.country_code = 'USA'
+      t = builder.country_select(:country_code, format: :with_alpha3)
+      expect(t).to include(tag)
+    end
+
+    it "marks priority countries as selected only once" do
+      ::CountrySelect::FORMATS[:with_alpha3] = lambda do |country|
+        [country.name, country.alpha3]
       end
+
+      tag = options_for_select([['United States of America', 'USA']], 'USA')
+      walrus.country_code = 'USA'
+      t = builder.country_select(:country_code, format: :with_alpha3, priority_countries: ['US'])
+      expect(t.scan(Regexp.new(Regexp.escape(tag))).size).to eq 1
     end
   end
 end