twitter_cldr 2.0.2 → 2.1.0

data/lib/twitter_cldr/shared/calendar.rb

@@ -8,39 +8,122 @@ module TwitterCldr
     class Calendar
 
       DEFAULT_FORMAT = :'stand-alone'
+      DEFAULT_PERIOD_FORMAT = :format
 
       NAMES_FORMS = [:wide, :narrow, :abbreviated]
+      ERAS_NAMES_FORMS = [:abbr, :name]
+
+      DATETIME_METHOD_MAP = {
+        :year_of_week_of_year => :year,
+        :quarter_stand_alone => :quarter,
+        :month_stand_alone => :month,
+        :day_of_month => :day,
+        :day_of_week_in_month => :day,
+        :weekday_local => :weekday,
+        :weekday_local_stand_alone => :weekday,
+        :second_fraction => :second,
+        :timezone_generic_non_location => :timezone,
+        :timezone_metazone => :timezone
+      }
+
+      REDIRECT_CONVERSIONS = {
+        :dayPeriods => :periods
+      }
 
       attr_reader :locale, :calendar_type
 
-      def initialize(locale = TwitterCldr.get_locale, calendar_type = TwitterCldr::DEFAULT_CALENDAR_TYPE)
+      def initialize(locale = TwitterCldr.locale, calendar_type = TwitterCldr::DEFAULT_CALENDAR_TYPE)
         @locale = TwitterCldr.convert_locale(locale)
         @calendar_type = calendar_type
       end
 
-      def months(names_form = :wide)
-        data = get_with_names_form(:months, names_form)
-        data && data.sort_by{ |m| m.first }.map { |m| m.last }
+      def months(names_form = :wide, format = DEFAULT_FORMAT)
+        data = get_with_names_form(:months, names_form, format)
+        data && data.sort_by { |m| m.first }.map { |m| m.last }
       end
 
-      def weekdays(names_form = :wide)
-        get_with_names_form(:days, names_form)
+      def weekdays(names_form = :wide, format = DEFAULT_FORMAT)
+        get_with_names_form(:days, names_form, format)
+      end
+
+      def fields
+        get_data(:fields)
+      end
+
+      def quarters(names_form = :wide, format = DEFAULT_FORMAT)
+        get_with_names_form(:quarters, names_form, format)
+      end
+
+      def periods(names_form = :wide, format = DEFAULT_PERIOD_FORMAT)
+        get_with_names_form(:periods, names_form, format)
+      end
+
+      def eras(names_form = :name)
+        get_data(:eras)[names_form]
+      end
+
+      def date_order(options = {})
+        get_order_for(TwitterCldr::Tokenizers::DateTokenizer, options)
+      end
+
+      def time_order(options = {})
+        get_order_for(TwitterCldr::Tokenizers::TimeTokenizer, options)
+      end
+
+      def datetime_order(options = {})
+        get_order_for(TwitterCldr::Tokenizers::DateTimeTokenizer, options)
       end
 
       private
 
-      def get_with_names_form(data_type, names_form)
-        get_data(data_type, DEFAULT_FORMAT, names_form) if NAMES_FORMS.include?(names_form.to_sym)
+      def calendar_cache
+        @@calendar_cache ||= {}
+      end
+
+      def get_order_for(const, options)
+        opts = options.merge(:locale => @locale)
+        cache_key = TwitterCldr::Utils.compute_cache_key([const.to_s] + opts.keys.sort + opts.values.sort)
+        calendar_cache.fetch(cache_key) do |key|
+          tokens = const.new(opts).tokens
+          calendar_cache[cache_key] = resolve_methods(methods_for_tokens(tokens))
+        end
+      end
+
+      def resolve_methods(methods)
+        methods.map { |method| DATETIME_METHOD_MAP.fetch(method, method) }
+      end
+
+      def methods_for_tokens(tokens)
+        tokens.inject([]) do |ret, token|
+          if token.type == :pattern
+            ret << TwitterCldr::Formatters::DateTimeFormatter::METHODS[token.value[0].chr]
+          end
+          ret
+        end
+      end
+
+      def get_with_names_form(data_type, names_form, format)
+        get_data(data_type, format, names_form) if NAMES_FORMS.include?(names_form.to_sym)
       end
 
       def get_data(*path)
-        data = TwitterCldr::Utils.traverse_hash(calendar_data, path)
-        redirect = parse_redirect(data)
-        redirect ? get_data(*redirect) : data
+        cache_key = TwitterCldr::Utils.compute_cache_key([@locale] + path)
+        calendar_cache.fetch(cache_key) do |key|
+          data = TwitterCldr::Utils.traverse_hash(calendar_data, path)
+          redirect = parse_redirect(data)
+          calendar_cache[key] = if redirect
+            get_data(*redirect)
+          else
+            data
+          end
+        end
       end
 
       def parse_redirect(data)
-        $1.split('.').map(&:to_sym) if data.is_a?(Symbol) && data.to_s =~ redirect_regexp
+        if data.is_a?(Symbol) && data.to_s =~ redirect_regexp
+          result = $1.split('.').map(&:to_sym)
+          result.map { |leg| REDIRECT_CONVERSIONS.fetch(leg, leg) }
+        end
       end
 
       def redirect_regexp

data/lib/twitter_cldr/shared/currencies.rb

@@ -7,32 +7,35 @@ module TwitterCldr
   module Shared
     module Currencies
       class << self
-        def countries
-          Kernel.warn("Currencies#countries will be deprecated. Please use Currencies#for_code.")
-          resource_countries.keys.map(&:to_s)
-        end
-
         def currency_codes(locale = :en)
           resource(locale).keys.map { |c| c.to_s }
         end
 
-        def for_country(country_name, locale = :en)
-          Kernel.warn("Currencies#for_country will be deprecated. Please use Currencies#for_code.")
-          for_code(resource_countries[country_name.to_sym][:code], locale) if resource_countries[country_name.to_sym]
-        end
-
         def for_code(currency_code, locale = :en)
           currency_code = currency_code.to_sym
           data = resource(locale)[currency_code]
-          { :currency => currency_code,
-            :name => data[:one],
-            :symbol => data[:symbol] } if data
+          symbol_data = iso_currency_symbols[currency_code]
+
+          if data
+            result = {
+              :currency    => currency_code,
+              :name        => data[:one],
+              :cldr_symbol => data[:symbol] || currency_code.to_s,
+              :symbol      => data[:symbol] || currency_code.to_s,
+              :code_points => (data[:symbol] || currency_code.to_s).unpack("U*")
+            }
+
+            result.merge!(symbol_data) if symbol_data
+          end
+
+          result
         end
 
         private
 
-        def resource_countries
-          @resource_countries ||= TwitterCldr.get_resource(:shared, :currencies)
+        # ISO 4217 to be precise
+        def iso_currency_symbols
+          @iso_currency_symbols ||= TwitterCldr.get_resource(:shared, :iso_currency_symbols)
         end
 
         def resource(locale)

data/lib/twitter_cldr/shared/languages.rb

@@ -10,7 +10,7 @@ module TwitterCldr
       class << self
 
         def all
-          all_for(TwitterCldr.get_locale)
+          all_for(TwitterCldr.locale)
         end
 
         def all_for(code)
@@ -20,16 +20,16 @@ module TwitterCldr
         end
 
         def from_code(code)
-          from_code_for_locale(code, TwitterCldr.get_locale)
+          from_code_for_locale(code, TwitterCldr.locale)
         end
 
-        def from_code_for_locale(code, locale = TwitterCldr.get_locale)
+        def from_code_for_locale(code, locale = TwitterCldr.locale)
           get_resource(locale)[:languages][TwitterCldr.convert_locale(code)]
         rescue
           nil
         end
 
-        def translate_language(language, source_locale = :en, dest_locale = TwitterCldr.get_locale)
+        def translate_language(language, source_locale = :en, dest_locale = TwitterCldr.locale)
           lang_code = get_resource(source_locale)[:languages].detect { |_, val| val.downcase == language.downcase }.first
           get_resource(dest_locale)[:languages][lang_code] if lang_code
         rescue

data/lib/twitter_cldr/shared/numbers.rb

@@ -9,7 +9,7 @@ module TwitterCldr
 
       class << self
 
-        def symbols(locale = TwitterCldr.get_locale)
+        def symbols(locale = TwitterCldr.locale)
           get_resource(TwitterCldr.convert_locale(locale))[:symbols] rescue nil
         end
 

data/lib/twitter_cldr/shared/territories.rb

@@ -0,0 +1,63 @@
+# encoding: UTF-8
+
+# Copyright 2012 Twitter, Inc
+# http://www.apache.org/licenses/LICENSE-2.0
+
+module TwitterCldr
+  module Shared
+    module Territories
+
+      class << self
+
+        def all
+          all_for(TwitterCldr.locale)
+        end
+
+        def all_for(code)
+          get_resource(code)[:territories]
+        rescue
+          {}
+        end
+
+        def from_territory_code(territory_code)
+          from_territory_code_for_locale(territory_code, TwitterCldr.locale)
+        end
+
+        # Returns how to say a given territory in a given locale.
+        #
+        # This method does not work for three-digit United Nation "area
+        # codes" (UN M.49; for example, 014 for Eastern Africa and 419 for Latin
+        # America).
+        def from_territory_code_for_locale(territory_code, locale = TwitterCldr.locale)
+          get_resource(locale)[:territories][TwitterCldr::Utils::Territories.normalize_territory_code(territory_code)]
+        rescue
+          nil
+        end
+
+        # Translates territory_name from source_locale to dest_locale.
+        #
+        # This method does not work for three-digit United Nation "area
+        # codes" (UN M.49; for example, 014 for Eastern Africa and 419 for Latin
+        # America).
+        def translate_territory(territory_name, source_locale = :en, dest_locale = TwitterCldr.locale)
+          territory_code, _ = get_resource(source_locale)[:territories].find do |_, other_territory_name|
+            other_territory_name.downcase == territory_name.downcase
+          end
+          get_resource(dest_locale)[:territories][territory_code] if territory_code
+        rescue
+          nil
+        end
+
+        protected
+
+        def get_resource(locale)
+          locale = TwitterCldr.convert_locale(locale)
+          TwitterCldr.get_locale_resource(locale, :territories)[locale]
+        end
+
+      end
+
+    end
+  end
+end
+

data/lib/twitter_cldr/shared.rb

@@ -14,5 +14,6 @@ module TwitterCldr
     autoload :PhoneCodes,    'twitter_cldr/shared/phone_codes'
     autoload :PostalCodes,   'twitter_cldr/shared/postal_codes'
     autoload :Bidi,          'twitter_cldr/shared/bidi'
+    autoload :Territories,     'twitter_cldr/shared/territories'
   end
-end
+end

data/lib/twitter_cldr/tokenizers/base.rb

@@ -54,10 +54,9 @@ module TwitterCldr
       end
 
       def tokens_for_pattern(pattern, path, additional_cache_key_params = [])
-        @@token_cache ||= {}
         cache_key = TwitterCldr::Utils.compute_cache_key(@locale, path.join('.'), type, format || "nil", *additional_cache_key_params)
 
-        unless @@token_cache.include?(cache_key)
+        unless token_cache.include?(cache_key)
           result = []
           tokens = expand_pattern(pattern)
 
@@ -69,33 +68,29 @@ module TwitterCldr
             end
           end
 
-          @@token_cache[cache_key] = result
+          token_cache[cache_key] = result
         end
 
-        @@token_cache[cache_key]
+        token_cache[cache_key]
       end
 
       def tokens_with_placeholders_for(key)
-        @@token_cache ||= {}
-        cache_key = compute_cache_key(@locale, key, type)
+        cache_key = TwitterCldr::Utils.compute_cache_key(@locale, key, type)
 
-        unless @@token_cache.include?(cache_key)
+        unless token_cache.include?(cache_key)
           result = []
           tokens = tokenize_pattern(pattern_for(traverse(key)))
           tokens.each do |token|
             result << token
           end
-          @@token_cache[cache_key] = result
+          token_cache[cache_key] = result
         end
-        @@token_cache[cache_key]
+
+        token_cache[cache_key]
       end
 
-      def compute_cache_key(*pieces)
-        if pieces && pieces.size > 0
-          pieces.join("|").hash
-        else
-          0
-        end
+      def token_cache
+        @@token_cache ||= {}
       end
 
       def init_placeholders

data/lib/twitter_cldr/tokenizers/calendars/additional_date_format_selector.rb

@@ -16,7 +16,8 @@ module TwitterCldr
         if !goal_pattern || goal_pattern.strip.empty?
           nil
         else
-          rank(goal_pattern).min do |(p1, score1), (p2, score2)|
+          cache_key = TwitterCldr::Utils.compute_cache_key(goal_pattern)
+          pattern_cache[cache_key] ||= rank(goal_pattern).min do |(p1, score1), (p2, score2)|
             score1 <=> score2
           end.first
         end
@@ -28,6 +29,10 @@ module TwitterCldr
 
       protected
 
+      def pattern_cache
+        @pattern_cache ||= {}
+      end
+
       def separate(pattern_key)
         last_char = ""
         pattern_key.each_char.each_with_index.inject([]) do |ret, (char, index)|

data/lib/twitter_cldr/tokenizers/calendars/datetime_tokenizer.rb

@@ -20,7 +20,7 @@ module TwitterCldr
             DateTokenizer::TOKEN_SPLITTER_REGEX,
             TimeTokenizer::TOKEN_SPLITTER_REGEX
           ),
-          :else => //
+          :else => /([^\s]+)/  # groups of non-space chars
         }
 
         @token_type_regexes = {
@@ -55,13 +55,18 @@ module TwitterCldr
       end
 
       def additional_format_selector
-        @additional_format_selector ||= AdditionalDateFormatSelector.new(
+        cache_key = TwitterCldr::Utils.compute_cache_key(@locale, @calendar_type)
+        @additional_format_selector = format_selector_cache[cache_key] ||= AdditionalDateFormatSelector.new(
           @resource[:calendars][@calendar_type][:additional_formats]
         )
       end
 
       protected
 
+      def format_selector_cache
+        @@format_selector_cache ||= {}
+      end
+
       def merge_token_type_regexes(first, second)
         TwitterCldr::Utils.deep_merge_hash(first, second) do |left, right|
           if right.is_a?(Regexp) && left.is_a?(Regexp)
@@ -116,6 +121,10 @@ module TwitterCldr
             resource.is_a?(Hash) ? resource[:pattern] : resource
         end
       end
+
+      def pattern_cache
+        @@pattern_cache ||= {}
+      end
     end
   end
 end

data/lib/twitter_cldr/tokenizers/calendars/timespan_tokenizer.rb

@@ -56,25 +56,28 @@ module TwitterCldr
       end
 
       def tokens(options = {})
+        # tokens_with_placeholders_for(full_path(:none, :second, :short, :two))
         path = full_path(options[:direction], options[:unit], options[:type])
         pluralization = options[:rule] || TwitterCldr::Formatters::Plurals::Rules.rule_for(options[:number], @locale)
+        available = traverse(path)
 
         case pluralization # sometimes the plural rule will return ":one" when the resource only contains a path with "1"
           when :zero
-            pluralization = 0 if token_exists(path + [0])
+            pluralization = 0 if available.include?(0)
           when :one
-            pluralization = 1 if token_exists(path + [1])
+            pluralization = 1 if available.include?(1)
           when :two
-            pluralization = 2 if token_exists(path + [2])
+            pluralization = 2 if available.include?(2)
         end
-        path << pluralization
 
-        tokens_with_placeholders_for(path) if token_exists(path)
-      end
+        if available.include?(pluralization)
+          path << pluralization
+        else
+          return [] unless available.keys.first
+          path << available.keys.first
+        end
 
-      def token_exists(path)
-        cache_key = compute_cache_key(@locale, path.join('.'))
-        token_cache.include?(cache_key) || !!traverse(path)
+        tokens_with_placeholders_for(path)
       end
 
       def all_types_for(unit, direction)

data/lib/twitter_cldr/tokenizers/numbers/number_tokenizer.rb

@@ -41,8 +41,8 @@ module TwitterCldr
       end
 
       def tokens(options = {})
-        @type = options[:type] || @type || :default
-        @format = options[:format] || @format || :default
+        @type = options[:type] || :default
+        @format = options[:format] || :default
 
         path = full_path
         positive, negative = traverse(path).to_s.split(/;/)

data/lib/twitter_cldr/utils/territories.rb

@@ -0,0 +1,56 @@
+# encoding: UTF-8
+
+# Copyright 2012 Twitter, Inc
+# http://www.apache.org/licenses/LICENSE-2.0
+
+module TwitterCldr
+  module Utils
+    module Territories
+      class << self
+
+        # Normalizes a territory code to a symbol.
+        #
+        # 1) Converts to string.
+        # 2) Downcases.
+        # 3) Symbolizes.
+        #
+        # The downcasing is to convert ISO 3166-1 alpha-2 codes,
+        # used (upper-case) for territories in CLDR, to be lowercase, to be
+        # consistent with how territory codes are surfaced in TwitterCLDR
+        # methods relating to phone and postal codes.
+        def normalize_territory_code(territory_code)
+          return nil if territory_code.nil?
+          territory_code.to_s.downcase.gsub(/^0+/, '').to_sym
+        end
+
+        # Normalizes each key in the 'arg' hash or constituent hashes as
+        # if it were a territory code.
+        #
+        # In addition, removes entries in hashes where the key begins with a digit.
+        # Because of the way the twitter-cldr-rb YAML resource pipeline works,
+        # these three-digit codes get mangled (e.g. interpreted as octal then
+        # reinterpreted out in decimal), and translations for UN three-digit
+        # area codes cannot be trusted.
+        def deep_normalize_territory_code_keys(arg)
+          case arg
+            when Array
+              arg.map { |elem| deep_normalize_territory_code_keys(elem) }
+            when Hash
+              normalized = arg.inject({}) do |carry, (key, value)|
+                normalized_key = normalize_territory_code(key)
+                carry[normalized_key] = deep_normalize_territory_code_keys(value)
+                carry
+              end
+              normalized.delete_if do |key, _|
+                key.to_s =~ /^\d+$/
+              end
+              normalized
+            else
+              arg
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/twitter_cldr/utils.rb

@@ -6,8 +6,9 @@
 module TwitterCldr
   module Utils
 
-    autoload :CodePoints, 'twitter_cldr/utils/code_points'
-    autoload :YAML,       'twitter_cldr/utils/yaml'
+    autoload :CodePoints,  'twitter_cldr/utils/code_points'
+    autoload :Territories, 'twitter_cldr/utils/territories'
+    autoload :YAML,        'twitter_cldr/utils/yaml'
 
     class << self
 
@@ -70,4 +71,4 @@ module TwitterCldr
   end
 end
 
-require 'twitter_cldr/utils/interpolation'
+require 'twitter_cldr/utils/interpolation'

data/lib/twitter_cldr/version.rb

@@ -4,5 +4,5 @@
 # http://www.apache.org/licenses/LICENSE-2.0
 
 module TwitterCldr
-  VERSION = "2.0.2"
+  VERSION = "2.1.0"
 end

data/lib/twitter_cldr.rb

@@ -23,6 +23,7 @@ module TwitterCldr
   autoload :Collation,     'twitter_cldr/collation'
   autoload :Localized,     'twitter_cldr/localized'
   autoload :Normalization, 'twitter_cldr/normalization'
+  autoload :Parsers,       'twitter_cldr/parsers'
   autoload :Resources,     'twitter_cldr/resources'
   autoload :Shared,        'twitter_cldr/shared'
   autoload :Tokenizers,    'twitter_cldr/tokenizers'
@@ -54,23 +55,53 @@ module TwitterCldr
 
   class << self
 
+    attr_writer :locale
+
     def resources
       @resources ||= TwitterCldr::Resources::Loader.new
     end
 
-    def get_locale
-      if defined?(FastGettext)
-        locale = FastGettext.locale
-        locale = DEFAULT_LOCALE if locale.to_s.empty?
-      else
-        locale = DEFAULT_LOCALE
+    def locale
+      locale = supported_locale?(@locale) ? @locale : find_fallback
+      locale = DEFAULT_LOCALE if locale.to_s.empty?
+      (supported_locale?(locale) ? locale : DEFAULT_LOCALE).to_sym
+    end
+
+    def with_locale(locale)
+      raise "Unsupported locale" unless supported_locale?(locale)
+
+      begin
+        old_locale = @locale
+        @locale = locale
+        result = yield
+      ensure
+        @locale = old_locale
+        result
       end
+    end
 
-      (supported_locale?(locale) ? locale : DEFAULT_LOCALE).to_sym
+    def register_locale_fallback(proc_or_locale)
+      case proc_or_locale
+        when Symbol, String, Proc
+          locale_fallbacks << proc_or_locale
+        else
+          raise "A locale fallback must be of type String, Symbol, or Proc."
+      end
+      nil
+    end
+
+    def reset_locale_fallbacks
+      locale_fallbacks.clear
+      TwitterCldr.register_locale_fallback(lambda { I18n.locale if defined?(I18n) && I18n.respond_to?(:locale) })
+      TwitterCldr.register_locale_fallback(lambda { FastGettext.locale if defined?(FastGettext) && FastGettext.respond_to?(:locale) })
+    end
+
+    def locale_fallbacks
+      @locale_fallbacks ||= []
     end
 
     def convert_locale(locale)
-      locale = locale.to_sym
+      locale = locale.to_sym if locale.respond_to?(:to_sym)
       TWITTER_LOCALE_MAP.fetch(locale, locale)
     end
 
@@ -86,8 +117,29 @@ module TwitterCldr
     def supported_locale?(locale)
       !!locale && supported_locales.include?(convert_locale(locale))
     end
+
+    protected
+
+    def find_fallback
+      locale_fallbacks.reverse_each do |fallback|
+        result = if fallback.is_a?(Proc)
+          begin
+            fallback.call
+          rescue
+            nil
+          end
+        else
+          fallback
+        end
+        return result if result
+      end
+      nil
+    end
+
   end
 
 end
 
+TwitterCldr.reset_locale_fallbacks
+
 require 'twitter_cldr/core_ext'

data/resources/collation/tailoring/hr.yml

@@ -0,0 +1,32 @@
+---
+:collator_options: {}
+:tailored_table: |-
+  0063 030C; [2C04, 5, 5]
+  0043 030C; [2C04, 5, 86]
+  0063 0301; [2C05, 5, 5]
+  0043 0301; [2C05, 5, 86]
+  0064 007A 030C; [2E04, 5, 5]
+  01C6; [2E04, 5, 6]
+  0044 007A 030C; [2E04, 5, 47]
+  01C5; [2E04, 5, 88]
+  0044 005A 030C; [2E04, 5, 89]
+  01C4; [2E04, 5, 8A]
+  0111; [2E05, 5, 5]
+  0110; [2E05, 5, 86]
+  006C 006A; [3E04, 5, 5]
+  01C9; [3E04, 5, 6]
+  004C 006A; [3E04, 5, 47]
+  01C8; [3E04, 5, 88]
+  004C 004A; [3E04, 5, 89]
+  01C7; [3E04, 5, 8A]
+  006E 006A; [4204, 5, 5]
+  01CC; [4204, 5, 6]
+  004E 006A; [4204, 5, 47]
+  01CB; [4204, 5, 88]
+  004E 004A; [4204, 5, 89]
+  01CA; [4204, 5, 8A]
+  0073 030C; [4C04, 5, 5]
+  0053 030C; [4C04, 5, 86]
+  007A 030C; [5A04, 5, 5]
+  005A 030C; [5A04, 5, 86]
+:suppressed_contractions: ''