country-select-engine 0.1.0

data/config/routes.rb

@@ -0,0 +1,2 @@
+Rails.application.routes.draw do
+end

data/country-select-engine.gemspec

@@ -0,0 +1,26 @@
+$:.push File.expand_path("../lib", __FILE__)
+
+# Maintain your gem's version:
+require "country-select-engine/version"
+
+# Describe your gem and declare its dependencies:
+Gem::Specification.new do |s|
+  s.name        = "country-select-engine"
+  s.version     = CountrySelectEngine::VERSION
+  s.authors     = ["Yen-Ju Chen", "Kristian Mandrup"]
+  s.email       = ["yjchenx@gmail.com", "kmandrup@gmail.com"]
+  s.homepage    = ""
+  s.summary     = "Rails engine for localized_country_select."
+  s.description = s.summary
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_dependency "rails", "~> 3.2.3"
+  # s.add_dependency "hpricot"
+  # s.add_dependency "jquery-rails"
+
+  s.add_development_dependency "sqlite3"
+end

data/lib/content_helper.rb

@@ -0,0 +1,43 @@
+=begin
+module CountrySelectEngine
+  module ContentHelper
+    def countries_yaml_content
+      countries.inject([]) do |output, country|
+        output << "    #{country[:code]}: \"#{country[:name]}\""
+        output
+      end.join("\n")
+    end
+
+    def countries_hash_content
+      countries.inject([]) do |output, country|
+        output << "    :#{country[:code]} => \"#{country[:name]}\","
+        output
+      end.join("\n")
+    end
+
+    def get_output
+      send :"#{file_ext}_output"
+    end
+
+    def yaml_output
+      output = %Q{#{locale}:
+  countries:
+#{countries_yaml_content}
+}
+    end
+
+    def rb_output
+      output = <<HASH
+{ 
+:#{locale} => {
+  :countries => {
+    #{countries_hash_content}      
+  }
+}
+}
+HASH
+    end
+    alias_method :yml_output, :yaml_output
+  end
+end
+=end

data/lib/country-select-engine/engine.rb

@@ -0,0 +1,4 @@
+module CountrySelectEngine
+  class Engine < ::Rails::Engine
+  end
+end

data/lib/country-select-engine/version.rb

@@ -0,0 +1,3 @@
+module CountrySelectEngine
+  VERSION = "0.1.0"
+end

data/lib/country-select-engine.rb

@@ -0,0 +1,181 @@
+require "country-select-engine/engine"
+
+# = CountrySelectEngine
+#
+# View helper for displaying select list with countries:
+#
+#     localized_country_select(:user, :country)
+#
+# Works just like the default Rails' +country_select+ plugin, 
+# but stores countries as
+# country *codes*, not *names*, in the database.
+#
+# You can easily translate country codes in your application like this:
+#     <%= I18n.t @user.country, :scope => 'countries' %>
+#
+# Uses the Rails internationalization framework (I18n) 
+# for translating the names of countries.
+#
+# Use Rake task <tt>rake import:country_select 'de'</tt> 
+# for importing country names
+# from Unicode.org's CLDR repository 
+# (http://www.unicode.org/cldr/data/charts/summary/root.html)
+#
+# Code adapted from Rails' default +country_select+ plugin (previously in core)
+# See http://github.com/rails/country_select/tree/master/lib/country_select.rb
+#
+module CountrySelectEngine
+  categories = ['currencies', 'countries', 'languages', 'timezones']
+  categories.each do |category|
+
+  # Returns array with codes and localized country names 
+  # (according to <tt>I18n.locale</tt>)
+  # for <tt><option></tt> tags
+  class_eval %Q{
+    def self.localized_#{category}_array options = {}
+      options.reverse_merge!(:sort => true)
+      res = []
+      list = I18n.translate(:#{category}).each do |key, value|
+        res << [self.value_with_symbol(key, value, options), key.to_s] if include_key?(key.to_s, options)
+      end
+      if options[:sort]
+        res.sort_by { |country| country.first.parameterize }
+      else
+        res
+      end
+    end
+  }
+
+  def self.value_with_symbol(key, value, options = {})
+    if options[:timezone]
+      timezone = ActiveSupport::TimeZone[key.to_s] 
+      if timezone
+        offset = "GMT#{ActiveSupport::TimeZone[key.to_s].formatted_offset}"
+        if options[:timezone] == :prepend 
+          return "(#{offset}) #{value}"
+        elsif options[:timezone] == :append 
+          return "#{value} (#{offset})"
+        end
+      else
+        return value
+      end
+    elsif options[:symbol] == :prepend
+      return "#{key.to_s}, #{value}"
+    elsif options[:symbol] == :append
+      return "#{value} (#{key.to_s})"
+    else
+      return value
+    end
+  end
+
+  def self.include_key?(key, options)
+    if options[:only]
+      return options[:only].include?(key)
+    end
+    if options[:except]
+      return !options[:except].include?(key)
+    end
+    true
+  end
+
+  # Return array with codes and localized country names 
+  # for array of country codes passed as argument
+  # == Example
+  #   priority_countries_array([:TW, :CN])
+  #   # => [ ['Taiwan', 'TW'], ['China', 'CN'] ]
+  class_eval %Q{
+    def self.priority_#{category}_array(country_codes=[])
+      countries = I18n.translate(:#{category})
+      country_codes.map { |code| [countries[code.to_s.to_sym]+' ('+code.to_s+')', code.to_s] }
+    end
+  }
+  end
+end
+
+module ActionView
+  module Helpers
+
+    module FormOptionsHelper
+      categories = ['currencies', 'countries', 'languages', 'timezones']
+
+      # Return select and option tags for the given object and method, using +localized_country_options_for_select+
+      # to generate the list of option tags. Uses <b>country code</b>, not name as option +value+.
+      # Country codes listed as an array of symbols in +priority_countries+ argument will be listed first
+      # TODO : Implement pseudo-named args with a hash, not the "somebody said PHP?" multiple args sillines
+      categories.each do |category|
+      class_eval %Q{
+      def localized_#{category.singularize}_select(object, method, priority_countries = nil, options = {}, html_options = {})
+        InstanceTag.new(object, method, self, options.delete(:object)).
+          to_localized_#{category.singularize}_select_tag(priority_countries, options, html_options)
+      end
+      }
+      end
+      alias_method :country_select, :localized_country_select
+
+      # Return "named" select and option tags according to given arguments.
+      # Use +selected_value+ for setting initial value
+      # It behaves likes older object-binded brother +localized_country_select+ otherwise
+      # TODO : Implement pseudo-named args with a hash, not the "somebody said PHP?" multiple args sillines
+      categories.each do |category|
+      class_eval %Q{
+      def localized_#{category.singularize}_select_tag(name, selected_value = nil, priority_countries = nil, html_options = {})
+        select_tag name.to_sym, localized_#{category.singularize}_options_for_select(selected_value, priority_countries).html_safe, html_options.stringify_keys
+      end
+      }
+      end
+      alias_method :country_select_tag, :localized_country_select_tag
+
+      # Returns a string of option tags for countries according to locale. Supply the country code in upper-case ('US', 'DE')
+      # as +selected+ to have it marked as the selected option tag.
+      # Country codes listed as an array of symbols in +priority_countries+ argument will be listed first
+      categories.each do |category|
+      class_eval %Q{
+      def localized_#{category.singularize}_options_for_select(selected = nil, priority_countries = nil, options = {})
+        country_options = ""
+        if priority_countries
+          country_options += options_for_select(CountrySelectEngine::priority_#{category}_array(priority_countries), selected)
+          country_options += "<option value='' disabled='disabled'>-------------</option>\n"
+          return country_options + options_for_select(CountrySelectEngine::localized_#{category}_array(options) - CountrySelectEngine::priority_#{category}_array(priority_countries), selected)
+        else
+          return country_options + options_for_select(CountrySelectEngine::localized_#{category}_array(options), selected)
+        end
+      end
+      }
+      end
+      alias_method :country_options_for_select, :localized_country_options_for_select
+
+    end
+
+    class InstanceTag
+      categories = ['currencies', 'countries', 'languages', 'timezones']
+      categories.each do |category|
+      class_eval %Q{
+      def to_localized_#{category.singularize}_select_tag(priority_countries, options, html_options)
+        html_options = html_options.stringify_keys
+        add_default_name_and_id(html_options)
+        value = options.has_key?(:selected) ? options[:selected] : value(object)
+        content_tag("select",
+          add_options(
+            localized_#{category.singularize}_options_for_select(value, priority_countries, options).html_safe,
+            options, value
+          ), html_options
+        )
+      end
+      }
+      end
+    end
+
+    class FormBuilder
+      categories = ['currencies', 'countries', 'languages', 'timezones']
+      categories.each do |category|
+      class_eval %Q{
+      def localized_#{category.singularize}_select(method, priority_countries = nil, options = {}, html_options = {})
+        @template.localized_#{category.singularize}_select(@object_name, method, priority_countries, options.merge(:object => @object), html_options)
+      end
+      }
+      end
+      alias_method :country_select, :localized_country_select
+    end
+
+  end
+end

data/lib/parse_helper.rb

@@ -0,0 +1,26 @@
+=begin
+module CountrySelectEngine
+  module ParseHelper
+    def get_code row  
+      code   = row.search("td[@class='g']").inner_text
+      code[-code.size, 2]
+    end
+
+    def get_name row
+      row.search("td[@class='v']").first.inner_text
+    end
+
+    def country_row? row    
+      row.search("td[@class='n']") && n_row?(row) && g_row?(row)           
+    end
+
+    def n_row? row
+      row.search("td[@class='n']").inner_html =~ /^namesterritory$/
+    end
+
+    def g_row? row
+      row.search("td[@class='g']").inner_html =~ /^[A-Z]{2}/
+    end
+  end  
+end
+=end

data/lib/tasks/import_locales.rake

@@ -0,0 +1,72 @@
+=begin
+require 'parse_helper'
+require 'content_helper'
+require 'hpricot'
+require 'open-uri'
+
+class CountrySelectEngine::Importer
+  include CountrySelectEngine::ParseHelper
+  include CountrySelectEngine::ContentHelper
+
+  def locale
+    @locale
+  end
+
+  def countries
+    @countries
+  end
+
+  def import(locales)
+    if locales.is_a?(String)
+      locales = locales.split(' ')
+    end
+    locales.each do |locale|
+      locale = locale.to_s
+      @locale = locale
+      # ----- Get the CLDR HTML ------
+      begin
+        puts "... getting the HTML file for locale '#{locale}'"
+        doc = Hpricot( open("http://www.unicode.org/cldr/data/charts/summary/#{locale}.html") )
+      rescue => e
+        puts "[!] Invalid locale name '#{locale}'! Not found in CLDR (#{e})"
+        exit 0
+      end
+
+      # ----- Parse the HTML with Hpricot ----
+      puts "... parsing the HTML file"
+      @countries = [] # reset countries list
+      doc.search("//tr").each do |row|
+        next if !country_row?(row)
+        countries << { :code => get_code(row).to_sym, :name => get_name(row).to_s }
+      end
+
+      # ----- Write the parsed values into file -----
+      puts "\n... writing the output"
+      filename = File.join(Rails.root, 'config', 'locales', "countries.#{locale}.yml")
+      puts filename
+      filename += '.NEW' if File.exists?(filename) # Append 'NEW' if file exists
+#      File.open(filename, 'w+') { |f| f << get_output }
+      File.open(filename, 'w+') { |f| f << yaml_output }
+
+      puts "\n---\nWritten values for the '#{locale}' into file: #{filename}\n"
+    end
+  end
+end
+=end
+
+=begin
+  task :find_place_by_google, :begin, :end, :needs => :environment do |t, args|
+    srand Time.now.to_i
+    puts args
+    (args.begin..args.end).each do |n|
+=end
+
+=begin
+namespace :country_select do
+  desc 'import locales'
+  task :import_locales, [:locales] do |t, args|
+    puts args
+    CountrySelectEngine::Importer.new.import(args.locales)
+  end
+end
+=end

data/script/convert_cldr.rb

@@ -0,0 +1,116 @@
+require 'yaml'
+
+# This script take the output of `ruby-cldr export --merge`, 
+# and convert into Rails locales for countries, languages and currencies.
+#
+# https://github.com/svenfuchs/rails-i18n
+# http://people.w3.org/rishida/utils/subtags/index.php
+available_currencies = ["AED", "AFN", "ALL", "AMD", "ANG", "AOA", "ARS",
+ "AUD", "AWG", "AZN", "BAM", "BBD", "BDT", "BGN",
+ "BHD", "BIF", "BMD", "BND", "BOB", "BRL", "BSD",
+ "BTN", "BWP", "BYR", "BZD", "CAD", "CDF", "CHF",
+ "CLP", "CNY", "COP", "CRC", "CUC", "CUP", "CVE",
+ "CZK", "DJF", "DKK", "DOP", "DZD", "EGP", "ERN",
+ "ETB", "EUR", "FJD", "FKP", "GBP", "GEL", "GHS",
+ "GIP", "GMD", "GNF", "GTQ", "GYD", "HKD", "HNL",
+ "HRK", "HTG", "HUF", "IDR", "ILS", "INR", "IQD",
+ "IRR", "ISK", "JMD", "JOD", "JPY", "KES", "KGS",
+ "KHR", "KMF", "KPW", "KRW", "KWD", "KYD", "KZT",
+ "LAK", "LBP", "LKR", "LRD", "LSL", "LTL", "LVL",
+ "LYD", "MAD", "MDL", "MGA", "MKD", "MMK", "MNT",
+ "MOP", "MRO", "MUR", "MVR", "MWK", "MXN", "MYR",
+ "MZN", "NAD", "NGN", "NIO", "NOK", "NPR", "NZD",
+ "OMR", "PAB", "PEN", "PGK", "PHP", "PKR", "PLN",
+ "PYG", "QAR", "RON", "RSD", "RUB", "RWF", "SAR",
+ "SBD", "SCR", "SDG", "SEK", "SGD", "SHP", "SKK",
+ "SLL", "SOS", "SRD", "STD", "SVC", "SYP", "SZL",
+ "THB", "TJS", "TMM", "TND", "TOP", "TRY", "TTD",
+ "TWD", "TZS", "UAH", "UGX", "USD", "UYU", "UZS",
+ "VEF", "VND", "VUV", "WST", "XAF", "XCD", "XOF",
+ "XPF", "YER", "ZAR", "ZMK", "ZWD", "EEK", "YEN", "GHC"]
+
+=begin
+locales = {
+  ar, az, bg, bn-IN, bs, ca, cs, csb, cy, da, de-AT, de-CH, dsb, el, en-AU, en-GB, en-IN, eo, es-AR, es-CL, es-CO, es-MX, es-PE, et, eu, fa, fi, fr-CA, fr-CH, fur, gl-ES, gsw-CH, he, hi, hi-IN, hr, hsb, hu, id, is, kn, ko, lo, lt, lv, mk, mn, nb, nl, nn, pl, pt-BR, pt-PT, rm, ro, sk, sl, sr, sr-Latn, sv-SE, sw, th, tl, tr, uk, vi, wo
+}
+=end
+locales = {
+  'de' => {    :locale => 'de',         :language => 'de' },
+  'en' => {    :locale => 'en',         :language => 'en' },
+  'en-US' => { :locale => 'en-US',      :language => 'en-US' },
+  'es' => {    :locale => 'es',         :language => 'es' },
+  'fr' => {    :locale => 'fr',         :language => 'fr' },
+  'it' => {    :locale => 'it',         :language => 'it' },
+  'ja' => {    :locale => 'ja',         :language => 'ja' },
+  'ru' => {    :locale => 'ru',         :language => 'ru' },
+  'zh-CN' => { :locale => 'zh-Hans-CN', :language => 'zh-Hans' },
+  'zh-TW' => { :locale => 'zh-Hant-TW', :language => 'zh-Hant' }
+}
+
+data_path = '../ruby-cldr/data/'
+output_path = 'config/locales/' # must be created
+currency_yaml = 'currencies.yml'
+language_yaml = 'languages.yml'
+country_yaml = 'territories.yml'
+
+# currencies
+locales.each do |k, v|
+  p = data_path+v[:locale]+'/'+currency_yaml
+  puts "read #{p}"
+  data = YAML.load_file(p)
+  list = {}
+  data[v[:locale]]['currencies'].each do |x, y|
+    list[x] = y['one'] if available_currencies.include?(x.upcase)
+  end
+  output = {k => {'currencies' => list}}
+  o = output_path+'currencies.'+k+'.yml'
+  puts "write #{o}"
+  s = YAML.dump(output)
+  s = s.lines.to_a[1..-1].join
+  f = File.open(o, 'w')
+  f.write(s)
+  f.close
+end
+
+# languages
+locales.each do |k, v|
+  p = data_path+v[:locale]+'/'+language_yaml
+  puts "read #{p}"
+  data = YAML.load_file(p)
+  list = {}
+  reverse_lookup = {}
+  locales.each do |x, y|
+    reverse_lookup[y[:language]] = x
+  end
+  puts reverse_lookup
+  data[v[:locale]]['languages'].each do |x, y|
+    list[reverse_lookup[x]] = y if reverse_lookup.keys.include?(x)
+  end
+  output = {k => {'languages' => list}}
+  o = output_path+'languages.'+k+'.yml'
+  puts "write #{o}"
+  s = YAML.dump(output)
+  s = s.lines.to_a[1..-1].join
+  f = File.open(o, 'w')
+  f.write(s)
+  f.close
+end
+
+# countries
+locales.each do |k, v|
+  p = data_path+v[:locale]+'/'+country_yaml
+  puts "read #{p}"
+  data = YAML.load_file(p)
+  list = {}
+  data[v[:locale]]['territories'].each do |x, y|
+    list[x] = y if (x.is_a?(String) && x.length == 2)
+  end
+  output = {k => {'countries' => list}}
+  o = output_path+'countries.'+k+'.yml'
+  puts "write #{o}"
+  s = YAML.dump(output)
+  s = s.lines.to_a[1..-1].join
+  f = File.open(o, 'w')
+  f.write(s)
+  f.close
+end

data/script/google.yml

@@ -0,0 +1,143 @@
+timezones:
+- International Date Line West
+- Midway Island
+- Samoa
+- Hawaii
+- Alaska
+- Pacific Time (US & Canada)
+- Tijuana
+- Mountain Time (US & Canada)
+- Arizona
+- Chihuahua
+- Mazatlan
+- Central Time (US & Canada)
+- Saskatchewan
+- Guadalajara
+- Mexico City
+- Monterrey
+- Central America
+- Eastern Time (US & Canada)
+- Indiana (East)
+- Bogota
+- Lima
+- Quito
+- Atlantic Time (Canada)
+- Caracas
+- La Paz
+- Santiago
+- Newfoundland
+- Brasilia
+- Buenos Aires
+- Georgetown
+- Greenland
+- Mid-Atlantic
+- Azores
+- Cape Verde Is.
+- Dublin
+- Edinburgh
+- Lisbon
+- London
+- Casablanca
+- Monrovia
+- UTC
+- Belgrade
+- Bratislava
+- Budapest
+- Ljubljana
+- Prague
+- Sarajevo
+- Skopje
+- Warsaw
+- Zagreb
+- Brussels
+- Copenhagen
+- Madrid
+- Paris
+- Amsterdam
+- Berlin
+- Bern
+- Rome
+- Stockholm
+- Vienna
+- West Central Africa
+- Bucharest
+- Cairo
+- Helsinki
+- Kyev
+- Riga
+- Sofia
+- Tallinn
+- Vilnius
+- Athens
+- Istanbul
+- Minsk
+- Jerusalem
+- Harare
+- Pretoria
+- Moscow
+- St. Petersburg
+- Volgograd
+- Kuwait
+- Riyadh
+- Nairobi
+- Baghdad
+- Tehran
+- Abu Dhabi
+- Muscat
+- Baku
+- Tbilisi
+- Yerevan
+- Kabul
+- Ekaterinburg
+- Islamabad
+- Karachi
+- Tashkent
+- Chennai
+- Kolkata
+- Mumbai
+- New Delhi
+- Kathmandu
+- Astana
+- Dhaka
+- Sri Jayawardenepura
+- Almaty
+- Novosibirsk
+- Rangoon
+- Bangkok
+- Hanoi
+- Jakarta
+- Krasnoyarsk
+- Beijing
+- Chongqing
+- Hong Kong
+- Urumqi
+- Kuala Lumpur
+- Singapore
+- Taipei
+- Perth
+- Irkutsk
+- Ulaan Bataar
+- Seoul
+- Osaka
+- Sapporo
+- Tokyo
+- Yakutsk
+- Darwin
+- Adelaide
+- Canberra
+- Melbourne
+- Sydney
+- Brisbane
+- Hobart
+- Vladivostok
+- Guam
+- Port Moresby
+- Magadan
+- Solomon Is.
+- New Caledonia
+- Fiji
+- Kamchatka
+- Marshall Is.
+- Auckland
+- Wellington
+- Nuku'alofa