twitter_cldr 3.0.0.beta1 → 3.0.0

data/lib/twitter_cldr/data_readers/timespan_data_reader.rb

@@ -0,0 +1,122 @@
+# encoding: UTF-8
+
+# Copyright 2012 Twitter, Inc
+# http://www.apache.org/licenses/LICENSE-2.0
+
+module TwitterCldr
+  module DataReaders
+    class TimespanDataReader < DataReader
+
+      DEFAULT_DIRECTION = :none
+      DEFAULT_TYPE = :default
+      VALID_UNITS = [:second, :minute, :hour, :day, :week, :month, :year]
+      BASE_PATH = [:units]
+
+      PATHS = {
+        :ago => {
+          :default => :'hour-past',
+          :second  => :'second-past',
+          :minute  => :'minute-past',
+          :hour    => :'hour-past',
+          :day     => :'day-past',
+          :week    => :'week-past',
+          :month   => :'month-past',
+          :year    => :'year-past'
+        },
+        :until => {
+          :default => :'hour-future',
+          :second  => :'second-future',
+          :minute  => :'minute-future',
+          :hour    => :'hour-future',
+          :day     => :'day-future',
+          :week    => :'week-future',
+          :month   => :'month-future',
+          :year    => :'year-future'
+        },
+        :none => {
+          :default => :second,
+          :second  => :second,
+          :minute  => :minute,
+          :hour    => :hour,
+          :day     => :day,
+          :week    => :week,
+          :month   => :month,
+          :year    => :year
+        }
+      }
+
+      attr_reader :direction, :unit, :type, :rule
+
+      def initialize(locale, seconds, options = {})
+        super(locale)
+
+        @type = options[:type] || DEFAULT_TYPE
+        @direction = options[:direction] || DEFAULT_DIRECTION
+        @unit = options[:unit]
+
+        @rule = options[:rule] ||
+          TwitterCldr::Formatters::Plurals::Rules.rule_for(seconds, locale)
+      end
+
+      # type is stuff like :abbreviated, etc
+      def pattern
+        path = full_path_for(direction, unit, type)
+        available = traverse(path)
+        pluralization = pluralization_for(rule, available)
+
+        if available.include?(pluralization)
+          path << pluralization
+        else
+          return [] unless available.keys.first
+          path << available.keys.first
+        end
+
+        traverse(path)
+      end
+
+      def tokenizer
+        TwitterCldr::Tokenizers::TimespanTokenizer.new(self)
+      end
+
+      def formatter
+        TwitterCldr::Formatters::TimespanFormatter.new(self)
+      end
+
+      def all_types
+        traverse(BASE_PATH + [PATHS[direction][unit]]).keys
+      end
+
+      protected
+
+      def default_type
+        all_types.first
+      end
+
+      def pluralization_for(rule, available)
+        # sometimes the plural rule will return ":one" when the resource only contains a path with "1"
+        case rule
+          when :zero
+            available.include?(0) ? 0 : rule
+          when :one
+            available.include?(1) ? 1 : rule
+          when :two
+            available.include?(2) ? 2 : rule
+          else
+            rule
+        end
+      end
+
+      def full_path_for(direction, unit, type)
+        BASE_PATH + [PATHS[direction][unit], type]
+      end
+
+      def resource
+        @resource = begin
+          raw = TwitterCldr.get_locale_resource(locale, :units)
+          raw[TwitterCldr.convert_locale(locale)]
+        end
+      end
+
+    end
+  end
+end

data/lib/twitter_cldr/data_readers.rb

@@ -0,0 +1,17 @@
+# encoding: UTF-8
+
+# Copyright 2012 Twitter, Inc
+# http://www.apache.org/licenses/LICENSE-2.0
+
+module TwitterCldr
+  module DataReaders
+    autoload :DataReader,         "twitter_cldr/data_readers/data_reader"
+    autoload :NumberDataReader,   "twitter_cldr/data_readers/number_data_reader"
+    autoload :CalendarDataReader, "twitter_cldr/data_readers/calendar_data_reader"
+    autoload :DateTimeDataReader, "twitter_cldr/data_readers/date_time_data_reader"
+    autoload :DateDataReader,     "twitter_cldr/data_readers/date_data_reader"
+    autoload :TimeDataReader,     "twitter_cldr/data_readers/time_data_reader"
+    autoload :TimespanDataReader, "twitter_cldr/data_readers/timespan_data_reader"
+    autoload :AdditionalDateFormatSelector, 'twitter_cldr/data_readers/additional_date_format_selector'
+  end
+end

data/lib/twitter_cldr/formatters/calendars/{datetime_formatter.rb → date_time_formatter.rb}

@@ -10,7 +10,8 @@ require 'tzinfo'
 
 module TwitterCldr
   module Formatters
-    class DateTimeFormatter < Base
+    class DateTimeFormatter < Formatter
+
       WEEKDAY_KEYS = [:sun, :mon, :tue, :wed, :thu, :fri, :sat]
       METHODS = { # ignoring u, l, g, j, A
         'G' => :era,
@@ -42,43 +43,26 @@ module TwitterCldr
         'V' => :timezone_metazone
       }
 
-      def initialize(options = {})
-        locale = extract_locale(options)
-        cache_key = TwitterCldr::Utils.compute_cache_key("datetime", locale, options[:calendar_type])
-        @tokenizer = tokenizer_cache[cache_key] ||= TwitterCldr::Tokenizers::DateTimeTokenizer.new(
-          :locale => locale,
-          :calendar_type => options[:calendar_type]
-        )
-      end
-
-      def result_for_token(token, index, date, options = {})
-        self.send(METHODS[token.value[0].chr], date, token.value, token.value.size, options)
-      end
-
-      def additional_format_selector
-        @tokenizer.additional_format_selector
-      end
+      protected
 
-      def self.additional_formats_for(locale)
-        new(:locale => locale).additional_format_selector.patterns.map(&:to_s)
+      def format_pattern(token, index, obj, options)
+        send(METHODS[token.value[0].chr], obj, token.value, token.value.size, options)
       end
 
-      protected
-
-      def tokenizer_cache
-        @@tokenizer_cache ||= {}
+      def calendar
+        data_reader.calendar
       end
 
-      # there is incomplete era data in CLDR for certain locales like Hindi
-      # fall back if that happens
+      # There is incomplete era data in CLDR for certain locales like Hindi.
+      # Fall back if that happens.
       def era(date, pattern, length, options = {})
         choices = case length
           when 0
             ["", ""]
           when 1..3
-            @tokenizer.calendar[:eras][:abbr]
+            calendar.eras(:abbr)
           else
-            @tokenizer.calendar[:eras][:name]
+            calendar.eras(:name)
         end
 
         if result = choices[date.year < 0 ? 0 : 1]
@@ -111,9 +95,9 @@ module TwitterCldr
           when 2
             quarter.to_s.rjust(length, '0')
           when 3
-            @tokenizer.calendar[:quarters][:format][:abbreviated][quarter]
+            calendar.quarters(:abbreviated, :format)[quarter]
           when 4
-            @tokenizer.calendar[:quarters][:format][:wide][quarter]
+            calendar.quarters(:wide, :format)[quarter]
         end
       end
 
@@ -126,12 +110,12 @@ module TwitterCldr
             quarter.to_s.rjust(length, '0')
           when 3
             raise NotImplementedError, 'requires cldr\'s "multiple inheritance"'
-            # @tokenizer.calendar[:quarters][:'stand-alone'][:abbreviated][key]
+            # calendar[:quarters][:'stand-alone'][:abbreviated][key]
           when 4
             raise NotImplementedError, 'requires cldr\'s "multiple inheritance"'
-            # @tokenizer.calendar[:quarters][:'stand-alone'][:wide][key]
+            # calendar[:quarters][:'stand-alone'][:wide][key]
           when 5
-            @tokenizer.calendar[:quarters][:'stand-alone'][:narrow][quarter]
+            calendar.quarters(:narrow)[quarter]
         end
       end
 
@@ -142,12 +126,12 @@ module TwitterCldr
           when 2
             date.month.to_s.rjust(length, '0')
           when 3
-            @tokenizer.calendar[:months][:format][:abbreviated][date.month]
+            calendar.months(:abbreviated, :format)[date.month - 1]
           when 4
-            @tokenizer.calendar[:months][:format][:wide][date.month]
+            calendar.months(:wide, :format)[date.month - 1]
           when 5
             raise NotImplementedError, 'requires cldr\'s "multiple inheritance"'
-            # @tokenizer.calendar[:months][:format][:narrow][date.month]
+            # calendar[:months][:format][:narrow][date.month]
           else
             # raise unknown date format
         end
@@ -160,11 +144,11 @@ module TwitterCldr
           when 2
             date.month.to_s.rjust(length, '0')
           when 3
-            @tokenizer.calendar[:months][:'stand-alone'][:abbreviated][date.month]
+            calendar.months(:abbreviated)[date.month - 1]
           when 4
-            @tokenizer.calendar[:months][:'stand-alone'][:wide][date.month]
+            calendar.months(:wide)[date.month - 1]
           when 5
-            @tokenizer.calendar[:months][:'stand-alone'][:narrow][date.month]
+            calendar.months(:narrow)[date.month - 1]
           else
             # raise unknown date format
         end
@@ -183,11 +167,11 @@ module TwitterCldr
         key = WEEKDAY_KEYS[date.wday]
         case length
           when 1..3
-            @tokenizer.calendar[:days][:format][:abbreviated][key]
+            calendar.weekdays(:abbreviated, :format)[key]
           when 4
-            @tokenizer.calendar[:days][:format][:wide][key]
+            calendar.weekdays(:wide, :format)[key]
           when 5
-            @tokenizer.calendar[:days][:'stand-alone'][:narrow][key]
+            calendar.weekdays(:narrow)[key]
         end
       end
 
@@ -215,7 +199,7 @@ module TwitterCldr
         # Always use :wide form. Day-period design was changed in CLDR -
         # http://cldr.unicode.org/development/development-process/design-proposals/day-period-design that means some
         # major changes are required for a full support of day periods.
-        @tokenizer.calendar[:periods][:format][:wide][time.strftime('%p').downcase.to_sym]
+        calendar.periods(:wide)[time.strftime('%p').downcase.to_sym]
       end
 
       def hour(time, pattern, length, options = {})
@@ -265,6 +249,7 @@ module TwitterCldr
       def timezone_generic_non_location(time, pattern, length, options = {})
         raise NotImplementedError, 'requires timezone translation data'
       end
+
     end
   end
 end

data/lib/twitter_cldr/formatters/calendars/timespan_formatter.rb

@@ -5,71 +5,10 @@
 
 module TwitterCldr
   module Formatters
-    class TimespanFormatter < Base
+    class TimespanFormatter < Formatter
 
-      DEFAULT_TYPE = :default
-      APPROXIMATE_MULTIPLIER = 0.75
-
-      TIME_IN_SECONDS = {
-        :second => 1,
-        :minute => 60,
-        :hour   => 3600,
-        :day    => 86400,
-        :week   => 604800,
-        :month  => 2629743.83,
-        :year   => 31556926
-      }
-
-      def initialize(options = {})
-        locale = extract_locale(options)
-        @direction = options[:direction]
-        cache_key = TwitterCldr::Utils.compute_cache_key(locale)
-        @tokenizer = tokenizer_cache[cache_key] ||= TwitterCldr::Tokenizers::TimespanTokenizer.new(
-          :locale => locale
-        )
-      end
-
-      def format(seconds, fmt_options = {})
-        options = fmt_options.dup
-        options[:type]      ||= DEFAULT_TYPE
-        options[:direction] ||= (seconds < 0 ? :ago : :until)
-        options[:unit]      ||= calculate_unit(seconds.abs, options)
-
-        options[:number] = calculate_time(seconds.abs, options[:unit])
-
-        tokens = @tokenizer.tokens(options)
-        strings = tokens.map { |token| token[:value] }
-        strings.join.gsub(/\{[0-9]\}/, options[:number].to_s)
-      end
-
-      protected
-
-      def tokenizer_cache
-        @@tokenizer_cache ||= {}
-      end
-
-      def calculate_unit(seconds, unit_options = {})
-        options = unit_options.dup
-        options[:approximate] = false if options[:approximate].nil?
-        multiplier = options[:approximate] ? APPROXIMATE_MULTIPLIER : 1
-
-        if seconds < (TIME_IN_SECONDS[:minute] * multiplier) then :second
-        elsif seconds < (TIME_IN_SECONDS[:hour] * multiplier) then :minute
-        elsif seconds < (TIME_IN_SECONDS[:day] * multiplier) then :hour
-        elsif seconds < (TIME_IN_SECONDS[:week] * multiplier) then :day
-        elsif seconds < (TIME_IN_SECONDS[:month] * multiplier) then :week
-        elsif seconds < (TIME_IN_SECONDS[:year] * multiplier) then :month
-        else :year end
-      end
-
-      # 0 <-> 29 secs                                                   # => seconds
-      # 30 secs <-> 44 mins, 29 secs                                    # => minutes
-      # 44 mins, 30 secs <-> 23 hrs, 59 mins, 29 secs                   # => hours
-      # 23 hrs, 59 mins, 29 secs <-> 29 days, 23 hrs, 59 mins, 29 secs  # => days
-      # 29 days, 23 hrs, 59 mins, 29 secs <-> 1 yr minus 1 sec          # => months
-      # 1 yr <-> max time or date                                       # => years
-      def calculate_time(seconds, unit)
-        (seconds.to_f / TIME_IN_SECONDS[unit].to_f).round.to_i
+      def format(tokens, number, options = {})
+        tokens.map(&:value).join.gsub(/\{[0-9]\}/, number.abs.to_s)
       end
 
     end

data/lib/twitter_cldr/formatters/formatter.rb

@@ -0,0 +1,39 @@
+# encoding: UTF-8
+
+# Copyright 2012 Twitter, Inc
+# http://www.apache.org/licenses/LICENSE-2.0
+
+module TwitterCldr
+  module Formatters
+    class Formatter
+
+      attr_reader :data_reader
+
+      def initialize(data_reader)
+        @data_reader = data_reader
+      end
+
+      def format(tokens, obj, options = {})
+        tokens.each_with_index.inject("") do |ret, (token, index)|
+          method_sym = :"format_#{token.type}"
+          ret << send(method_sym, token, index, obj, options)
+        end
+      end
+
+      protected
+
+      def format_plaintext(token, index, obj, options)
+        if match = token.value.match(/([\s]*)'(.*)'([\s]*)/)
+          match.captures.join
+        else
+          token.value
+        end
+      end
+
+      def format_composite(token, index, obj, options)
+        eval(format(token.tokens, obj)).to_s
+      end
+
+    end
+  end
+end

data/lib/twitter_cldr/formatters/list_formatter.rb

@@ -5,33 +5,39 @@
 
 module TwitterCldr
   module Formatters
-    class ListFormatter < Base
+    class ListFormatter < Formatter
 
       attr_accessor :locale
 
-      def initialize(options = {})
-        @locale = TwitterCldr.convert_locale(extract_locale(options))
+      def initialize(locale = TwitterCldr.locale)
+        @locale = TwitterCldr.convert_locale(locale)
       end
 
-      def format(list)
-        if resource.include?(list.size)
-          compose(resource[list.size], list)
-        else
-          compose_list(list)
+      def format(list, type = :default)
+        if res = resource_for_type(type)
+          if res.include?(list.size)
+            compose(res[list.size], list)
+          else
+            compose_list(list, res)
+          end
         end
       end
 
+      def types
+        resource.keys
+      end
+
       protected
 
-      def compose_list(list)
-        result = compose(resource[:end] || resource[:middle] || "", [list[-2], list[-1]])
+      def compose_list(list, res)
+        result = compose(res[:end] || res[:middle] || "", [list[-2], list[-1]])
 
         # Ruby ranges don't support subtraction for some reason (eg. -3..-5).
         # Instead, we use a positive counter and negate it on array access.
         (3..list.size).each do |i|
           format_sym = i == list.size ? :start : :middle
-          format_sym = :middle unless resource.include?(format_sym)
-          result = compose(resource[format_sym] || "", [list[-i], result])
+          format_sym = :middle unless res.include?(format_sym)
+          result = compose(res[format_sym] || "", [list[-i], result])
         end
 
         result
@@ -55,6 +61,10 @@ module TwitterCldr
         end
       end
 
+      def resource_for_type(type)
+        resource[type]
+      end
+
       def resource
         @resource ||= TwitterCldr.get_locale_resource(@locale, :lists)[@locale][:lists]
       end

data/lib/twitter_cldr/formatters/numbers/abbreviated/abbreviated_number_formatter.rb

@@ -6,36 +6,14 @@
 module TwitterCldr
   module Formatters
     class AbbreviatedNumberFormatter < NumberFormatter
-      NUMBER_MAX = 10 ** (TwitterCldr::Tokenizers::NumberTokenizer::ABBREVIATED_MAX_POWER + 1)
-      NUMBER_MIN = 10 ** TwitterCldr::Tokenizers::NumberTokenizer::ABBREVIATED_MIN_POWER
-
-      def default_format_options_for(number)
-        { :precision => 0 }
-      end
-
-      def get_tokens(obj, options = {})
-        type = (obj < NUMBER_MAX) && (obj >= NUMBER_MIN) ? get_type : :decimal
-        format = type == get_type ? get_key(obj) : nil
-        opts = options.merge(
-          :sign => obj.abs == obj ? :positive : :negative,
-          :type => type,
-          :format => format
-        )
-        @tokenizer.tokens(opts)
-      end
 
       protected
 
-      def get_type
-        :decimal
-      end
-
-      def get_key(number)
-        "1#{"0" * (number.to_i.to_s.size - 1)}".to_i
-      end
-
       def transform_number(number)
-        if (number < NUMBER_MAX) && (number >= NUMBER_MIN)
+        within = number < TwitterCldr::DataReaders::NumberDataReader::NUMBER_MAX &&
+          number >= TwitterCldr::DataReaders::NumberDataReader::NUMBER_MIN
+
+        if within
           power = (((number.to_s.length - 1) / 3) * 3).floor
           factor = (10 ** power).to_f
           number / factor
@@ -43,6 +21,7 @@ module TwitterCldr
           number
         end
       end
+
     end
   end
 end

data/lib/twitter_cldr/formatters/numbers/currency_formatter.rb

@@ -6,10 +6,8 @@
 module TwitterCldr
   module Formatters
     class CurrencyFormatter < NumberFormatter
-      DEFAULT_CURRENCY_SYMBOL = "$"
-      DEFAULT_PRECISION = 2
 
-      def format(number, options = {})
+      def format(tokens, number, options = {})
         options[:currency] ||= "USD"
         currency = TwitterCldr::Shared::Currencies.for_code(options[:currency])
         currency ||= {
@@ -27,7 +25,7 @@ module TwitterCldr
 
         symbol = options[:use_cldr_symbol] ? currency[:cldr_symbol] : currency[:symbol]
         symbol ||= currency[:currency].to_s
-        super(number, options).gsub('¤', symbol)
+        super.gsub('¤', symbol)
       end
 
       private
@@ -37,13 +35,6 @@ module TwitterCldr
         @resource[code.to_sym] || @resource[:DEFAULT]
       end
 
-      def get_tokens(obj, options = {})
-        opts = options.dup.merge(
-          :sign => obj.abs == obj ? :positive : :negative,
-          :type => :currency
-        )
-        @tokenizer.tokens(opts)
-      end
     end
   end
 end

data/lib/twitter_cldr/formatters/numbers/decimal_formatter.rb

@@ -6,11 +6,13 @@
 module TwitterCldr
   module Formatters
     class DecimalFormatter < NumberFormatter
-      def format(number, options = {})
-        super(number, options)
+
+      def format(tokens, number, options = {})
+        super
       rescue TypeError, ArgumentError
         number
       end
+
     end
   end
 end

data/lib/twitter_cldr/formatters/numbers/number_formatter.rb

@@ -5,35 +5,45 @@
 
 module TwitterCldr
   module Formatters
-    class NumberFormatter < Base
-      attr_reader :symbols
+    class NumberFormatter < Formatter
 
-      DEFAULT_SYMBOLS = { :group => ',', :decimal => '.', :plus_sign => '+', :minus_sign => '-' }
+      DEFAULT_SYMBOLS = {
+        :group => ',',
+        :decimal => '.',
+        :plus_sign => '+',
+        :minus_sign => '-'
+      }
 
-      def initialize(options = {})
-        locale = extract_locale(options)
-        cache_key = TwitterCldr::Utils.compute_cache_key(locale)
-        @tokenizer = tokenizer_cache[cache_key] ||= TwitterCldr::Tokenizers::NumberTokenizer.new(
-          :locale => locale
-        )
-        @symbols = DEFAULT_SYMBOLS.merge(tokenizer.symbols)
+      attr_reader :data_reader
+
+      def initialize(data_reader)
+        @data_reader = data_reader
       end
 
-      def format(number, opts = {})
-        opts[:precision] ||= precision_from(number)
-        prefix, suffix, integer_format, fraction_format = *partition_tokens(get_tokens(number, opts))
+      def format(tokens, number, options = {})
+        options[:precision] ||= precision_from(number)
+        options[:type] ||= :decimal
+
+        prefix, suffix, integer_format, fraction_format = *partition_tokens(tokens)
         number = transform_number(number)
 
-        int, fraction = parse_number(number, opts)
-        result =  integer_format.apply(int, opts)
-        result << fraction_format.apply(fraction, opts) if fraction
-        "#{prefix.to_s}#{result}#{suffix.to_s}"
+        int, fraction = parse_number(number, options)
+        result =  integer_format.apply(int, options)
+        result << fraction_format.apply(fraction, options) if fraction
+
+        numbering_system(options[:type]).transliterate(
+          "#{prefix.to_s}#{result}#{suffix.to_s}"
+        )
       end
 
       protected
 
-      def tokenizer_cache
-        @@tokenizer_cache ||= {}
+      # data readers should encapsulate formatting options, and when they do, this "type"
+      # argument will no longer be necessary (accessible via `data_reader.type` instead)
+      def numbering_system(type)
+        @numbering_system ||= TwitterCldr::Shared::NumberingSystem.for_name(
+          data_reader.number_system_for(type)
+        )
       end
 
       def transform_number(number)
@@ -41,10 +51,22 @@ module TwitterCldr
       end
 
       def partition_tokens(tokens)
-        [tokens[0] || "",
-         tokens[2] || "",
-         Numbers::Integer.new(tokens[1], @tokenizer.symbols),
-         Numbers::Fraction.new(tokens[1], @tokenizer.symbols)]
+        [
+          token_val_from(tokens[0]),
+          token_val_from(tokens[2]),
+          Numbers::Integer.new(
+            tokens[1],
+            data_reader.symbols
+          ),
+          Numbers::Fraction.new(
+            tokens[1],
+            data_reader.symbols
+          )
+        ]
+      end
+
+      def token_val_from(token)
+        token ? token.value : ""
       end
 
       def parse_number(number, options = {})
@@ -71,10 +93,6 @@ module TwitterCldr
         parts.size == 2 ? parts[1].size : 0
       end
 
-      def get_tokens(obj, options = {})
-        opts = options.dup.merge(:sign => obj.abs == obj ? :positive : :negative)
-        @tokenizer.tokens(opts)
-      end
     end
   end
 end