country_select 1.3.1 → 2.0.0.rc1

data/lib/country_select.rb

@@ -1,130 +1,12 @@
-# CountrySelect
-#
-# Adds #country_select method to
-# ActionView::FormBuilder
-#
-require 'country_select/version'
-require 'country_select/countries'
-
-module ActionView
-  module Helpers
-    module FormOptionsHelper
-      #
-      # Return select and option tags
-      # for the given object and method,
-      # using country_options_for_select to
-      # generate the list of option tags.
-      #
-      def country_select(object, method, priority_countries = nil,
-                                         options = {},
-                                         html_options = {})
-
-        tag = if defined?(ActionView::Helpers::InstanceTag) &&
-                ActionView::Helpers::InstanceTag.instance_method(:initialize).arity != 0
-
-                InstanceTag.new(object, method, self, options.delete(:object))
-              else
-                CountrySelect.new(object, method, self, options)
-              end
-
-        tag.to_country_select_tag(priority_countries, options, html_options)
-      end
-
-      #
-      # Returns a string of option tags for
-      # pretty much any country in the world.
-      #
-      # You can also supply an array of countries as
-      # +priority_countries+ so that they will be
-      # listed above the rest of the (long) list.
-      #
-      # NOTE: Only the option tags are returned, you
-      # have to wrap this call in a regular HTML
-      # select tag.
-      #
-      def country_options_for_select(selected = nil, priority_countries = nil, use_iso_codes = false, use_locale = nil)
-        country_options = "".html_safe
-
-        if priority_countries
-          priority_countries_options = if use_iso_codes || ::CountrySelect.use_iso_codes
-                                         # Codes should not be downcased, but they were previous to 1.3
-                                         # which means they should continue to be until 2.0 is released in
-                                         # order to prevent breakage with existing implementations
-                                         #
-                                         # In 2.0.0, this map should actually be upcasing the codes
-                                         priority_countries.map! { |code| code.to_s.downcase }
+# encoding: utf-8
 
-                                         priority_countries.map do |code|
-                                           [
-                                             ::CountrySelect::countries(use_locale)[code],
-                                             code
-                                           ]
-                                         end
-                                       else
-                                         priority_countries
-                                       end
+require 'iso3166'
 
-          country_options += options_for_select(priority_countries_options, selected)
-          country_options += "<option value=\"\" disabled=\"disabled\">-------------</option>\n".html_safe
-          #
-          # prevents selected from being included
-          # twice in the HTML which causes
-          # some browsers to select the second
-          # selected option (not priority)
-          # which makes it harder to select an
-          # alternative priority country
-          #
-          selected = nil if priority_countries.include?(selected)
-        end
-
-        values = if use_iso_codes || ::CountrySelect.use_iso_codes
-                   ::CountrySelect::countries(use_locale).invert
-                 else
-                   ::CountrySelect::countries(use_locale).values
-                 end
-
-        return country_options + options_for_select(values.sort, selected)
-      end
-
-      # All the countries included in the country_options output.
-    end
-
-    module ToCountrySelectTag
-      def to_country_select_tag(priority_countries, options, html_options)
-        use_iso_codes = options.delete(:iso_codes)
-        use_locale = options.delete(:locale)
-        html_options = html_options.stringify_keys
-        add_default_name_and_id(html_options)
-        value = value(object)
-        content_tag("select",
-          add_options(
-            country_options_for_select(value, priority_countries, use_iso_codes, use_locale),
-            options, value
-          ), html_options
-        )
-      end
-    end
-
-    if defined?(ActionView::Helpers::InstanceTag) &&
-        ActionView::Helpers::InstanceTag.instance_method(:initialize).arity != 0
-      class InstanceTag
-        include ToCountrySelectTag
-      end
-    else
-      class CountrySelect < Tags::Base
-        include ToCountrySelectTag
-      end
-    end
-
-    class FormBuilder
-      def country_select(method, priority_countries = nil,
-                                 options = {},
-                                 html_options = {})
+require 'country_select/version'
+require 'country_select/tag_helper'
 
-        @template.country_select(@object_name, method, priority_countries,
-                                                       options.merge(:object => @object),
-                                                       html_options)
-      end
-    end
-  end
+if defined?(ActionView::Helpers::Tags::Base)
+  require 'country_select/country_select_helper'
+else
+  require 'country_select/rails3/country_select_helper'
 end

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/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, country_option_tags, html_options)
+        end
+      end
+    end
+  end
+end

data/lib/country_select/tag_helper.rb

@@ -0,0 +1,88 @@
+module CountrySelect
+  module TagHelper
+    def country_option_tags
+      option_tags_options = {
+        :selected => @options.fetch(:selected) { value(@object) },
+        :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)
+
+        if priority_countries.include?(option_tags_options[:selected])
+          option_tags_options[:selected] = nil
+        end
+
+        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 country_options
+      country_options_for(all_country_codes, true)
+    end
+
+    def all_country_codes
+      codes = ISO3166::Country.all.map(&:last)
+
+      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|
+          code = code.to_s.upcase
+
+          unless country = ISO3166::Country.new(code)
+            code = ISO3166::Country.find_by_name(code).first
+          end
+
+          country ||= ISO3166::Country.new(code)
+          default_name = country.name
+          localized_name = country.translations[I18n.locale.to_s]
+
+          name = localized_name || default_name
+
+          [name,code]
+        end
+        sorted ? country_list.sort : country_list
+      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.3.1"
+  VERSION = "2.0.0.rc1"
 end

data/spec/country_select_spec.rb

@@ -1,166 +1,139 @@
+# encoding: utf-8
+
 require 'spec_helper'
 
 require 'action_view'
 require 'country_select'
 
-module ActionView
-  module Helpers
-
-    describe CountrySelect do
-      include TagHelper
-
-      class Walrus
-        attr_accessor :country_name
-      end
-
-      let(:walrus) { Walrus.new }
-
-      let!(:template) { ActionView::Base.new }
-
-      let(:select_tag) do
-        "<select id=\"walrus_country_name\" name=\"walrus[country_name]\">"
-      end
-
-      let(:selected_us_option) do
-        if defined?(Tags::Base)
-          content_tag(:option, 'United States of America', :selected => :selected, :value => "United States of America")
-        else
-          "<option value=\"United States of America\" selected=\"selected\">United States of America</option>"
-        end
-      end
-
-      let(:selected_iso_us_option) do
-        if defined?(Tags::Base)
-          content_tag(:option, 'United States of America', :selected => :selected, :value => 'us')
-        else
-          "<option value=\"us\" selected=\"selected\">United States of America</option>"
-        end
-      end
-
-      let(:builder) do
-        if defined?(Tags::Base)
-          FormBuilder.new(:walrus, walrus, template, {})
-        else
-          FormBuilder.new(:walrus, walrus, template, {}, Proc.new { })
-        end
-      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("en").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 of America'
-            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 of America']) }
-
-          it "puts the countries at the top" do
-            tag.should include("#{select_tag}<option value=\"United States of America")
-          end
-
-          it "inserts a divider" do
-            tag.should include(">United States of America</option><option value=\"\" disabled=\"disabled\">-------------</option>")
-          end
-
-          it "does not mark two countries as selected" do
-            walrus.country_name = "United States of America"
-            str = <<-EOS.strip
-              </option>\n<option value="United States of America" selected="selected">United States of America</option>
-            EOS
-            tag.should_not include(str)
-          end
-        end
-      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("en").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 "#country_select with global option" do
-          before do
-            ::CountrySelect.use_iso_codes = true
-          end
-
-          after do
-            ::CountrySelect.use_iso_codes = false
-          end
-
-          let(:tag) { builder.country_select(:country_name, nil) }
-
-          it "creates option tags of the countries" do
-            ::CountrySelect::countries("en").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)
-            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 of America</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 of America</option>
-            EOS
-            tag.should_not include(str)
-          end
-        end
-      end
-      context "different language selected" do
-        describe "'es' selected as the instance language" do
-          let(:tag) { builder.country_select(:country_name, ['us'], {:iso_codes => true, :locale => 'es'}) }
-
-          it "displays spanish names" do
-            tag.should include(">Estados Unidos</option><option value=\"\" disabled=\"disabled\">-------------</option>")
-          end
-        end
-      end
+describe "CountrySelect" do
+  include ActionView::Helpers::TagHelper
+  include ActionView::Helpers::FormOptionsHelper
+
+  class Walrus
+    attr_accessor :country_code
+  end
+
+  let(:walrus) { Walrus.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
+    <<-EOS.chomp.strip
+      <select id="walrus_country_code" name="walrus[country_code]">
+    EOS
+  end
+
+  it "selects the value of country_code" do
+    tag = options_for_select([['United States of America', '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
+    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
+    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 of America','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
+
+  it "selects only the first matching option" do
+    tag = options_for_select([["United States of America", "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
+
+  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 of America", "US"]])
+    walrus.country_code = 'DE'
+    t = builder.country_select(:country_code, except: ['US'])
+    expect(t).to_not include(tag)
+  end
+
+  context "using old 1.x syntax" do
+    it "accepts priority countries" do
+      tag = options_for_select(
+        [
+          ['Latvia','LV'],
+          ['United States of America','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 of America", "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 of America", "US"]
+      ])
+      country_names = ["Australia", "Canada", "United Kingdom", "United States"]
+      t = builder.country_select(:country_code, country_names)
+      expect(t).to include(tag)
     end
   end
 end