twitter_cldr 1.0.0

data/lib/formatters/calendars/datetime_formatter.rb

@@ -0,0 +1,217 @@
+# This class has been adapted from Sven Fuch's ruby-cldr gem
+# See LICENSE for the accompanying license for his contributions
+
+module TwitterCldr
+  module Formatters
+    class DateTimeFormatter < Base
+      WEEKDAY_KEYS = [:sun, :mon, :tue, :wed, :thu, :fri, :sat]
+      METHODS = { # ignoring u, l, g, j, A
+        'G' => :era,
+        'y' => :year,
+        'Y' => :year_of_week_of_year,
+        'Q' => :quarter,
+        'q' => :quarter_stand_alone,
+        'M' => :month,
+        'L' => :month_stand_alone,
+        'w' => :week_of_year,
+        'W' => :week_of_month,
+        'd' => :day,
+        'D' => :day_of_month,
+        'F' => :day_of_week_in_month,
+        'E' => :weekday,
+        'e' => :weekday_local,
+        'c' => :weekday_local_stand_alone,
+        'a' => :period,
+        'h' => :hour,
+        'H' => :hour,
+        'K' => :hour,
+        'k' => :hour,
+        'm' => :minute,
+        's' => :second,
+        'S' => :second_fraction,
+        'z' => :timezone,
+        'Z' => :timezone,
+        'v' => :timezone_generic_non_location,
+        'V' => :timezone_metazone
+      }
+
+      def initialize(options = {})
+        @tokenizer = TwitterCldr::Tokenizers::DateTimeTokenizer.new(:locale => extract_locale(options))
+      end
+
+      def result_for_token(token, index, date)
+        self.send(METHODS[token.value[0].chr], date, token.value, token.value.size)
+      end
+
+      protected
+
+      def era(date, pattern, length)
+        raise 'not implemented'
+      end
+
+      def year(date, pattern, length)
+        year = date.year.to_s
+        year = year.length == 1 ? year : year[-2, 2] if length == 2
+        year = year.rjust(length, '0') if length > 1
+        year
+      end
+
+      def year_of_week_of_year(date, pattern, length)
+        raise 'not implemented'
+      end
+
+      def day_of_week_in_month(date, pattern, length) # e.g. 2nd Wed in July
+        raise 'not implemented'
+      end
+
+      def quarter(date, pattern, length)
+        quarter = (date.month.to_i - 1) / 3 + 1
+        case length
+        when 1
+          quarter.to_s
+        when 2
+          quarter.to_s.rjust(length, '0')
+        when 3
+          @tokenizer.calendar[:quarters][:format][:abbreviated][quarter]
+        when 4
+          @tokenizer.calendar[:quarters][:format][:wide][quarter]
+        end
+      end
+
+      def quarter_stand_alone(date, pattern, length)
+        quarter = (date.month.to_i - 1) / 3 + 1
+        case length
+        when 1
+          quarter.to_s
+        when 2
+          quarter.to_s.rjust(length, '0')
+        when 3
+          raise 'not yet implemented (requires cldr\'s "multiple inheritance")'
+          # @tokenizer.calendar[:quarters][:'stand-alone'][:abbreviated][key]
+        when 4
+          raise 'not yet implemented (requires cldr\'s "multiple inheritance")'
+          # @tokenizer.calendar[:quarters][:'stand-alone'][:wide][key]
+        when 5
+          @tokenizer.calendar[:quarters][:'stand-alone'][:narrow][quarter]
+        end
+      end
+
+      def month(date, pattern, length)
+        case length
+        when 1
+          date.month.to_s
+        when 2
+          date.month.to_s.rjust(length, '0')
+        when 3
+          @tokenizer.calendar[:months][:format][:abbreviated][date.month]
+        when 4
+          @tokenizer.calendar[:months][:format][:wide][date.month]
+        when 5
+          raise 'not yet implemented (requires cldr\'s "multiple inheritance")'
+          @tokenizer.calendar[:months][:format][:narrow][date.month]
+        else
+          # raise unknown date format
+        end
+      end
+
+      def month_stand_alone(date, pattern, length)
+        case length
+        when 1
+          date.month.to_s
+        when 2
+          date.month.to_s.rjust(length, '0')
+        when 3
+          raise 'not yet implemented (requires cldr\'s "multiple inheritance")'
+          @tokenizer.calendar[:months][:'stand-alone'][:abbreviated][date.month]
+        when 4
+          raise 'not yet implemented (requires cldr\'s "multiple inheritance")'
+          @tokenizer.calendar[:months][:'stand-alone'][:wide][date.month]
+        when 5
+          @tokenizer.calendar[:months][:'stand-alone'][:narrow][date.month]
+        else
+          # raise unknown date format
+        end
+      end
+
+      def day(date, pattern, length)
+        case length
+        when 1
+          date.day.to_s
+        when 2
+          date.day.to_s.rjust(length, '0')
+        end
+      end
+
+      def weekday(date, pattern, length)
+        key = WEEKDAY_KEYS[date.wday]
+        case length
+        when 1..3
+          @tokenizer.calendar[:days][:format][:abbreviated][key]
+        when 4
+          @tokenizer.calendar[:days][:format][:wide][key]
+        when 5
+          @tokenizer.calendar[:days][:'stand-alone'][:narrow][key]
+        end
+      end
+
+      def weekday_local(date, pattern, length)
+        # "Like E except adds a numeric value depending on the local starting day of the week"
+        raise 'not implemented (need to defer a country to lookup the local first day of week from weekdata)'
+      end
+
+      def weekday_local_stand_alone(date, pattern, length)
+        raise 'not implemented (need to defer a country to lookup the local first day of week from weekdata)'
+      end
+
+      def period(time, pattern, length)
+        @tokenizer.calendar[:periods][time.strftime('%p').downcase.to_sym]
+      end
+
+      def hour(time, pattern, length)
+        hour = time.hour
+        hour = case pattern[0, 1]
+        when 'h' # [1-12]
+          hour > 12 ? (hour - 12) : (hour == 0 ? 12 : hour)
+        when 'H' # [0-23]
+          hour
+        when 'K' # [0-11]
+          hour > 11 ? hour - 12 : hour
+        when 'k' # [1-24]
+          hour == 0 ? 24 : hour
+        end
+        length == 1 ? hour.to_s : hour.to_s.rjust(length, '0')
+      end
+
+      def minute(time, pattern, length)
+        length == 1 ? time.min.to_s : time.min.to_s.rjust(length, '0')
+      end
+
+      def second(time, pattern, length)
+        length == 1 ? time.sec.to_s : time.sec.to_s.rjust(length, '0')
+      end
+
+      def second_fraction(time, pattern, length)
+        raise 'can not use the S format with more than 6 digits' if length > 6
+        (time.usec.to_f / 10 ** (6 - length)).round.to_s.rjust(length, '0')
+      end
+
+      def timezone(time, pattern, length)
+        case length
+        when 1..3
+          time.zone
+        else
+          "UTC #{time.strftime("%z")}"
+        end
+      end
+
+      def timezone_generic_non_location(time, pattern, length)
+        raise 'not yet implemented (requires timezone translation data")'
+      end
+
+      def round_to(number, precision)
+        factor = 10 ** precision
+        (number * factor).round.to_f / factor
+      end
+    end
+  end
+end

data/lib/formatters/calendars/time_formatter.rb

@@ -0,0 +1,9 @@
+module TwitterCldr
+  module Formatters
+    class TimeFormatter < DateTimeFormatter
+      def initialize(options = {})
+        @tokenizer = TwitterCldr::Tokenizers::TimeTokenizer.new(:locale => extract_locale(options))
+      end
+    end
+  end
+end

data/lib/formatters/numbers/currency_formatter.rb

@@ -0,0 +1,25 @@
+module TwitterCldr
+  module Formatters
+    class CurrencyFormatter < NumberFormatter
+      DEFAULT_FORMAT_OPTIONS = { :precision => 2 }
+      DEFAULT_CURRENCY_SYMBOL = "$"
+
+      def initialize(options = {})
+        @tokenizer = TwitterCldr::Tokenizers::NumberTokenizer.new(:locale => self.extract_locale(options), :type => :currency)
+        super
+      end
+
+      def format(number, options = {})
+        if options[:currency]
+          currency ||= TwitterCldr::Shared::Currencies.for_code(options[:currency])
+          currency ||= TwitterCldr::Shared::Currencies.for_country(options[:currency])
+          currency ||= { :symbol => options[:currency] }
+        else
+          currency = { :symbol => DEFAULT_CURRENCY_SYMBOL }
+        end
+
+        super(number, DEFAULT_FORMAT_OPTIONS.merge(options)).gsub('¤', currency[:symbol])
+      end
+    end
+  end
+end

data/lib/formatters/numbers/decimal_formatter.rb

@@ -0,0 +1,22 @@
+module TwitterCldr
+  module Formatters
+    class DecimalFormatter < NumberFormatter
+      def initialize(options = {})
+        @tokenizer = TwitterCldr::Tokenizers::NumberTokenizer.new(:locale => self.extract_locale(options), :type => :decimal)
+        super
+      end
+
+      def format(number, options = {})
+        super(Float(number), options)
+      rescue TypeError, ArgumentError
+        number
+      end
+
+      protected
+
+      def get_tokens(obj, options = {})
+        obj.abs == obj ? @tokenizer.tokens(:sign => :positive) : @tokenizer.tokens(:sign => :negative)
+      end
+    end
+  end
+end

data/lib/formatters/numbers/helpers/base.rb

@@ -0,0 +1,18 @@
+module TwitterCldr
+  module Formatters
+    module Numbers
+      class Base
+        def interpolate(string, value, orientation = :right)
+          value  = value.to_s
+          length = value.length
+          start, pad = orientation == :left ? [0, :rjust] : [-length, :ljust]
+
+          string = string.dup
+          string = string.ljust(length, '#') if string.length < length
+          string[start, length] = value
+          string.gsub('#', '')
+        end
+      end
+    end
+  end
+end

data/lib/formatters/numbers/helpers/fraction.rb

@@ -0,0 +1,29 @@
+module TwitterCldr
+  module Formatters
+    module Numbers
+      class Fraction < Base
+        attr_reader :format, :decimal, :precision
+
+        def initialize(token, symbols = {})
+          @format  = token ? token.value.split('.').pop : ''
+          @decimal = symbols[:decimal] || '.'
+          @precision = @format.length
+        end
+
+        def apply(fraction, options = {})
+          precision = options[:precision] || self.precision
+          if precision > 0
+            decimal + interpolate(format(options), fraction, :left)
+          else
+            ''
+          end
+        end
+
+        def format(options)
+          precision = options[:precision] || self.precision
+          precision ? '0' * precision : @format
+        end
+      end
+    end
+  end
+end

data/lib/formatters/numbers/helpers/integer.rb

@@ -0,0 +1,46 @@
+module TwitterCldr
+  module Formatters
+    module Numbers
+      class Integer < Base
+        attr_reader :format, :separator, :groups
+
+        def initialize(token, symbols = {})
+          format     = token.value.split('.')[0]
+          @format    = prepare_format(format, symbols)
+          @groups    = parse_groups(format)
+          @separator = symbols[:group] || ','
+        end
+
+        def apply(number, options = {})
+          format_groups(interpolate(format, number.to_i))
+        end
+
+        def format_groups(string)
+          return string if groups.empty?
+          tokens = []
+          tokens << chop_group(string, groups.first)
+          tokens << chop_group(string, groups.last) while string.length > groups.last
+          tokens << string
+          tokens.compact.reverse.join(separator)
+        end
+
+        def parse_groups(format)
+          return [] unless index = format.rindex(',')
+          rest   = format[0, index]
+          widths = [format.length - index - 1]
+          widths << rest.length - rest.rindex(',') - 1 if rest.rindex(',')
+          widths.compact.uniq
+        end
+
+        def chop_group(string, size)
+          string.slice!(-size, size) if string.length > size
+        end
+
+        def prepare_format(format, symbols)
+          signs = symbols.values_at(:plus_sign, :minus_sign)
+          format.tr(',', '').tr('+-', signs.join)
+        end
+      end
+    end
+  end
+end

data/lib/formatters/numbers/number_formatter.rb

@@ -0,0 +1,48 @@
+module TwitterCldr
+  module Formatters
+    class NumberFormatter < Base
+      attr_reader :symbols
+
+      DEFAULT_SYMBOLS = { :group => ',', :decimal => '.', :plus_sign => '+', :minus_sign => '-' }
+
+      def initialize(options = {})
+        @symbols = DEFAULT_SYMBOLS.merge(tokenizer.symbols)
+      end
+
+      def format(number, options = {})
+        opts = { :precision => precision_from(number) }.merge(options)
+        prefix, suffix, integer_format, fraction_format = *partition_tokens(self.get_tokens(number, opts))
+        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}"
+      end
+
+      protected
+
+      def partition_tokens(tokens)
+        [tokens[0] || "",
+         tokens[2] || "",
+         Numbers::Integer.new(tokens[1], @tokenizer.symbols),
+         Numbers::Fraction.new(tokens[1], @tokenizer.symbols)]
+      end
+
+      def parse_number(number, options = {})
+        precision = options[:precision] || self.precision_from(number)
+        number = round_to(number, precision)
+        number.abs.to_s.split(".")
+      end
+
+      def round_to(number, precision)
+        factor = 10 ** precision
+        (number * factor).round.to_f / factor
+      end
+
+      def precision_from(num)
+        parts = num.to_s.split(".")
+        parts.size == 2 ? parts[1].size : 0
+      end
+    end
+  end
+end

data/lib/formatters/numbers/percent_formatter.rb

@@ -0,0 +1,18 @@
+module TwitterCldr
+  module Formatters
+    class PercentFormatter < NumberFormatter
+      DEFAULT_PERCENT_SIGN = "%"
+      DEFAULT_FORMAT_OPTIONS = { :precision => 0 }
+
+      def initialize(options = {})
+        @tokenizer = TwitterCldr::Tokenizers::NumberTokenizer.new(:locale => self.extract_locale(options), :type => :percent)
+        super
+      end
+
+      def format(number, options = {})
+        opts = DEFAULT_FORMAT_OPTIONS.merge(options)
+        super(number, opts).gsub('¤', @tokenizer.symbols[:percent_sign] || DEFAULT_PERCENT_SIGN)
+      end
+    end
+  end
+end

data/lib/formatters/plurals/rules.rb

@@ -0,0 +1,34 @@
+module TwitterCldr
+  module Formatters
+    module Plurals
+      class Rules
+        class << self
+          def all
+            all_for(TwitterCldr::get_locale)
+          end
+
+          def all_for(locale)
+            locale = TwitterCldr.convert_locale(locale.to_sym)
+            get_resource(locale)[locale][:i18n][:plural][:keys]
+          rescue => e
+            []
+          end
+
+          def rule_for(number, locale = TwitterCldr::get_locale)
+            locale = TwitterCldr.convert_locale(locale.to_sym)
+            get_resource(locale)[locale][:i18n][:plural][:rule].call(number)
+          rescue => e
+            :other
+          end
+
+          protected
+
+          def get_resource(locale)
+            locale = TwitterCldr.convert_locale(locale)
+            eval(TwitterCldr.resources.resource_for(locale, "plurals")[locale])
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shared/currencies.rb

@@ -0,0 +1,33 @@
+module TwitterCldr
+  module Shared
+    class Currencies
+      @@resource = TwitterCldr.resources.resource_for("shared", "currencies")[:shared][:currencies]
+
+      class << self
+        def countries
+          @@resource.map { |country_name, data| country_name.to_s }
+        end
+
+        def currency_codes
+          @@resource.map { |country_name, data| data[:code] }
+        end
+
+        def for_country(country_name)
+          @@resource[country_name.to_sym]
+        end
+
+        def for_code(currency_code)
+          final = nil
+          @@resource.each_pair do |country_name, data|
+            if data[:code] == currency_code
+              final = data.merge({ :country => country_name.to_s })
+              final.delete(:code)
+              break
+            end
+          end
+          final
+        end
+      end
+    end
+  end
+end

data/lib/shared/languages.rb

@@ -0,0 +1,48 @@
+module TwitterCldr
+  module Shared
+    class Languages
+      class << self
+        def all
+          all_for(TwitterCldr::get_locale)
+        end
+
+        def all_for(code)
+          get_resource(TwitterCldr.convert_locale(code.to_sym))[:languages]
+        rescue => e
+          {}
+        end
+
+        def from_code(code)
+          from_code_for_locale(code, TwitterCldr::get_locale)
+        end
+
+        def from_code_for_locale(code, locale = TwitterCldr::get_locale)
+          get_resource(TwitterCldr.convert_locale(locale.to_sym))[:languages][TwitterCldr.convert_locale(code.to_sym)]
+        rescue => e
+          nil
+        end
+
+        def translate_language(language, source_locale = :en, dest_locale = TwitterCldr::get_locale)
+          source_locale = TwitterCldr.convert_locale(source_locale.to_sym)
+          lang_code = get_resource(source_locale)[:languages].select { |key, val| val.downcase == language.downcase }.flatten.first
+
+          if lang_code
+            dest_locale = TwitterCldr.convert_locale(dest_locale.to_sym)
+            get_resource(dest_locale)[:languages][lang_code.to_sym]
+          else
+            nil
+          end
+        rescue => e
+          nil
+        end
+
+        protected
+
+        def get_resource(locale)
+          locale = TwitterCldr.convert_locale(locale)
+          TwitterCldr.resources.resource_for(locale, "languages")[locale]
+        end
+      end
+    end
+  end
+end

data/lib/shared/resources.rb

@@ -0,0 +1,45 @@
+module TwitterCldr
+  module Shared
+    class Resources
+      def initialize
+        @resources_by_locale = {}
+      end
+
+      def resource_for(locale, resource)
+        locale = locale.to_sym
+        unless @resources_by_locale.include?(locale)
+          @resources_by_locale[locale] = {}
+        end
+
+        unless @resources_by_locale[locale].include?(resource)
+          @resources_by_locale[locale][resource] = data_for(locale, resource)
+        end
+
+        @resources_by_locale[locale][resource]
+      end
+
+      protected
+
+      def data_for(locale, resource)
+        deep_symbolize_keys(YAML.load(File.read(TwitterCldr.get_resource_file(locale, resource))))
+      end
+
+      # adapted from: http://snippets.dzone.com/posts/show/11121 (first comment)
+      def deep_symbolize_keys(arg)
+        case arg
+          when Array then
+            arg.map { |elem| deep_symbolize_keys(elem) }
+          when Hash then
+            Hash[
+              arg.map do |key, value|
+                k = key.is_a?(String) ? key.to_sym : key
+                v = deep_symbolize_keys(value)
+                [k, v]
+              end]
+          else
+            arg
+        end
+      end
+    end
+  end
+end

data/lib/shared/timezones.rb

@@ -0,0 +1 @@
+# not yet implemented