twitter_cldr 3.0.0.beta1 → 3.0.0

data/lib/twitter_cldr/formatters/numbers/rbnf/rule_set.rb

@@ -0,0 +1,259 @@
+# encoding: UTF-8
+
+# Copyright 2012 Twitter, Inc
+# http://www.apache.org/licenses/LICENSE-2.0
+
+require 'bigdecimal'
+
+module TwitterCldr
+  module Formatters
+    module Rbnf
+
+      RuleSet = Struct.new(:rules, :name, :access) do
+        def rule_for_value(base_value)
+          if idx = rule_index_for(base_value)
+            rules[idx]
+          end
+        end
+
+        def previous_rule_for(rule)
+          if idx = rule_index_for(rule.base_value)
+            rules[idx - 1] if idx > 0
+          end
+        end
+
+        def master_rule
+          rule_for_value(Rule::MASTER)
+        end
+
+        def improper_fraction_rule
+          rule_for_value(Rule::IMPROPER_FRACTION)
+        end
+
+        def proper_fraction_rule
+          rule_for_value(Rule::PROPER_FRACTION)
+        end
+
+        def negative_rule
+          rule_for_value(Rule::NEGATIVE)
+        end
+
+        def private?
+          access == "private"
+        end
+
+        def public?
+          access == "public"
+        end
+
+        def each_numeric_rule
+          if block_given?
+            search_start_index.upto(rules.size - 1) do |i|
+              yield rules[i]
+            end
+          else
+            to_enum(:each_numeric_rule)
+          end
+        end
+
+        # fractional: i.e. whether or not to consider the rule set a "fractional" rule set (special rules apply)
+        def rule_for(number, fractional = false)
+          if fractional
+            fractional_rule_for(number)
+          else
+            normal_rule_for(number)
+          end
+        end
+
+        private
+
+        # Adapted from: http://grepcode.com/file/repo1.maven.org/maven2/com.ibm.icu/icu4j/51.2/com/ibm/icu/text/NFRuleSet.java#NFRuleSet.findFractionRuleSetRule%28double%29
+        def fractional_rule_for(number)
+          # the obvious way to do this (multiply the value being formatted
+          # by each rule's base value until you get an integral result)
+          # doesn't work because of rounding error.  This method is more
+          # accurate
+
+          # find the least common multiple of the rules' base values
+          # and multiply this by the number being formatted.  This is
+          # all the precision we need, and we can do all of the rest
+          # of the math using integer arithmetic
+          index = search_start_index
+          index += 1 while rules[index].base_value == 0
+          least_common_multiple = rules[index].base_value
+
+          (index + 1).upto(rules.size - 1) do |i|
+            least_common_multiple = lcm(least_common_multiple, rules[i].base_value)
+          end
+
+          numerator = (number * least_common_multiple).round
+
+          # for each rule, do the following...
+          difference = 10 ** 30  # some absurdly large number
+          winner = 0;
+
+          index.upto(rules.size - 1) do |i|
+            # "numerator" is the numerator of the fraction is the
+            # denominator is the LCD.  The numerator if the the rule's
+            # base value is the denomiator is "numerator" times the
+            # base value divided bythe LCD.  Here we check to see if
+            # that's an integer, and if not, how close it is to being
+            # an integer.
+            temp_difference = numerator * BigDecimal.new(rules[i].base_value) % least_common_multiple
+
+            # normalize the result of the above calculation: we want
+            # the numerator's distance from the CLOSEST multiple
+            # of the LCD
+            if (least_common_multiple - temp_difference) < temp_difference
+              temp_difference = least_common_multiple - temp_difference
+            end
+
+            # if this is as close as we've come, keep track of how close
+            # that is, and the line number of the rule that did it.  If
+            # we've scored a direct hit, we don't have to look at any more
+            # rules
+            if temp_difference < difference
+              difference = temp_difference
+              winner = i
+
+              break if difference == 0
+            end
+          end
+
+          # if we have two successive rules that both have the winning base
+          # value, then the first one (the one we found above) is used if
+          # the numerator of the fraction is 1 and the second one is used if
+          # the numerator of the fraction is anything else (this lets us
+          # do things like "one third"/"two thirds" without haveing to define
+          # a whole bunch of extra rule sets)
+          if (winner + 1) < rules.length && rules[winner + 1].base_value == rules[winner].base_value
+            if (number * rules[winner].base_value).round < 1 || (number * rules[winner].base_value).round >= 2
+              winner += 1
+            end
+          end
+
+          # finally, return the winning rule
+          rules[winner]
+        end
+
+        # Adapted from: http://grepcode.com/file/repo1.maven.org/maven2/com.ibm.icu/icu4j/51.2/com/ibm/icu/text/NFRuleSet.java#NFRuleSet.lcm%28long%2Clong%29
+        def lcm(x, y)
+          # binary gcd algorithm from Knuth, "The Art of Computer Programming,"
+          # vol. 2, 1st ed., pp. 298-299
+          x1 = x
+          y1 = y
+          p2 = 0
+
+          while (x1 & 1) == 0 && (y1 & 1) == 0
+            p2 += 1
+            x1 >>= 1
+            y1 >>= 1
+          end
+
+          t = (x1 & 1) == 1 ? -y1 : x1
+
+          while t != 0
+            t >>= 1 while (t & 1) == 0
+            t > 0 ? x1 = t : y1 = -t
+            t = x1 - y1
+          end
+
+          gcd = x1 << p2
+          x / gcd * y
+        end
+
+        # If the rule set is a regular rule set, do the following:
+        #
+        # If the rule set includes a master rule (and the number was passed in as a double), use the master rule.  (If the number being formatted was passed in as a long, the master rule is ignored.)
+        # If the number is negative, use the negative-number rule.
+        # If the number has a fractional part and is greater than 1, use the improper fraction rule.
+        # If the number has a fractional part and is between 0 and 1, use the proper fraction rule.
+        # Binary-search the rule list for the rule with the highest base value less than or equal to the number. If that rule has two substitutions, its base value is not an even multiple of its divisor, and the number is an even multiple of the rule's divisor, use the rule that precedes it in the rule list. Otherwise, use the rule itself.
+
+        def normal_rule_for(number)
+          if rule = master_rule
+            rule
+          elsif number < 0 && rule = negative_rule
+            rule
+          elsif contains_fraction?(number) && number > 1 && rule = improper_fraction_rule
+            rule
+          elsif contains_fraction?(number) && number > 0 && number < 1 && rule = proper_fraction_rule
+            rule
+          else
+            if rule = rule_for_value(number.abs)
+              use_prev_rule = rule.substitution_count == 2 &&
+                !rule.even_multiple_of?(rule.base_value) &&
+                rule.even_multiple_of?(number)
+
+              if use_prev_rule
+                previous_rule_for(rule)
+              else
+                rule
+              end
+            else
+              rules[search_start_index] || rules.first
+            end
+          end
+        end
+
+        def contains_fraction?(number)
+          number != number.floor
+        end
+
+        def rule_index_for(base_value)
+          if rule_index = special_rule_index_for(base_value)
+            return rule_index
+          end
+
+          if is_numeric?(base_value)
+            # binary search (base_value must be a number for this to work)
+            low = search_start_index
+            high = rules.size - 1
+
+            while low <= high
+              mid = (low + high) / 2
+
+              case
+                when rules[mid].base_value > base_value
+                  high = mid - 1
+                when rules[mid].base_value < base_value
+                  low = mid + 1
+                else
+                  break
+              end
+            end
+
+            # Binary-search the rule list for the rule with the highest base value less than or equal to the number.
+            if rules[mid].base_value <= base_value
+              mid
+            else
+              mid > 0 ? mid - 1 : mid
+            end
+          end
+        end
+
+        def special_rule_index_for(base_value)
+          (0...search_start_index).each do |i|
+            if rules[i].base_value == base_value
+              return i
+            end
+          end
+          nil
+        end
+
+        def search_start_index
+          @search_start_index ||= begin
+            rules.find_index do |rule|
+              is_numeric?(rule.base_value)
+            end || 0
+          end
+        end
+
+        def is_numeric?(val)
+          !!(val.to_s =~ /\A[\d]+\.?[\d]{0,}\z/)
+        end
+      end
+
+    end
+  end
+end

data/lib/twitter_cldr/formatters/numbers/rbnf/substitution.rb

@@ -0,0 +1,30 @@
+# encoding: UTF-8
+
+# Copyright 2012 Twitter, Inc
+# http://www.apache.org/licenses/LICENSE-2.0
+
+module TwitterCldr
+  module Formatters
+    module Rbnf
+
+      Substitution = Struct.new(:type, :contents, :length) do
+        def description
+          @description ||= contents.map(&:value).join
+        end
+
+        def rule_set_reference
+          if item = contents.first
+            item.value.gsub("%", "") if item.type == :rule
+          end
+        end
+
+        def decimal_format
+          if item = contents.first
+            item.value if item.type == :decimal
+          end
+        end
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,127 @@
+# encoding: UTF-8
+
+# Copyright 2012 Twitter, Inc
+# http://www.apache.org/licenses/LICENSE-2.0
+
+module TwitterCldr
+  module Formatters
+    module Rbnf
+
+      [:InvalidRbnfTokenError, :RuleFormatter, :NormalRuleFormatter,
+      :NegativeRuleFormatter, :MasterRuleFormatter, :ProperFractionRuleFormatter,
+      :ImproperFractionRuleFormatter].each do |formatter|
+        autoload formatter, "twitter_cldr/formatters/numbers/rbnf/formatters"
+      end
+
+      autoload :Rule,         "twitter_cldr/formatters/numbers/rbnf/rule"
+      autoload :RuleSet,      "twitter_cldr/formatters/numbers/rbnf/rule_set"
+      autoload :RuleGroup,    "twitter_cldr/formatters/numbers/rbnf/rule_group"
+      autoload :RuleParser,   "twitter_cldr/formatters/numbers/rbnf/rule_parser"
+      autoload :Substitution, "twitter_cldr/formatters/numbers/rbnf/substitution"
+
+      class PrivateRuleSetError < StandardError; end
+
+      class RbnfFormatter
+
+        DEFAULT_SPELLOUT_OPTIONS = {
+          :rule_group => "SpelloutRules",
+          :rule_set => "spellout-numbering"
+        }
+
+        attr_reader :locale
+
+        def initialize(locale = TwitterCldr.locale)
+          @locale = TwitterCldr.convert_locale(locale)
+        end
+
+        def format(number, options = {})
+          rule_group_name, rule_set_name = *if options[:rule_group].nil? && options[:rule_set].nil?
+            [DEFAULT_CARDINAL_OPTIONS[:rule_group], DEFAULT_CARDINAL_OPTIONS[:rule_set]]
+          else
+            [options[:rule_group], options[:rule_set]]
+          end
+
+          if rule_group = rule_group_by_name(rule_group_name)
+            if rule_set = rule_group.rule_set_for(rule_set_name)
+              if rule_set.public?
+                RuleFormatter.format(number, rule_set, rule_group, locale)
+              else
+                raise PrivateRuleSetError.new(
+                  "#{rule_set_name} is a private rule set and cannot be used directly."
+                )
+              end
+            end
+          end
+        end
+
+        def group_names
+          @group_names ||= resource.map { |g| g[:type] }
+        end
+
+        def rule_set_names_for_group(group_name)
+          cache_key = TwitterCldr::Utils.compute_cache_key(locale, group_name)
+
+          rule_set_name_cache[cache_key] ||= begin
+            if rule_group = rule_group_by_name(group_name)
+              rule_group.rule_sets.inject([]) do |ret, rule_set|
+                ret << rule_set.name if rule_set.public?
+                ret
+              end
+            end
+          end
+
+          rule_set_name_cache[cache_key] || []
+        end
+
+        private
+
+        def rule_group_by_name(name)
+          cache_key = TwitterCldr::Utils.compute_cache_key(locale, name)
+
+          rule_group_cache[cache_key] ||= begin
+            group_data = resource.find do |group|
+              group[:type] == name
+            end
+
+            if group_data
+              rule_group_from_resource(group_data)
+            end
+          end
+        end
+
+        def rule_group_cache
+          @@rule_group_cache ||= {}
+        end
+
+        def rule_set_name_cache
+          @@rule_set_name_cache ||= {}
+        end
+
+        def rule_set_from_resource(rule_set_data)
+          RuleSet.new(
+            rule_set_data[:rules].map do |rule|
+              binding.pry unless rule[:rule].is_a?(String)
+              Rule.new(rule[:value], rule[:rule], rule[:radix])
+            end,
+            rule_set_data[:type],
+            rule_set_data[:access] || "public"
+          )
+        end
+
+        def rule_group_from_resource(group_data)
+          RuleGroup.new(
+            group_data[:ruleset].map do |rule_set_data|
+              rule_set_from_resource(rule_set_data)
+            end,
+            group_data[:type]
+          )
+        end
+
+        def resource
+          @resource ||= TwitterCldr.resources.get_locale_resource(locale, "rbnf")[locale][:rbnf][:grouping]
+        end
+
+      end
+    end
+  end
+end

data/lib/twitter_cldr/formatters/plurals/plural_formatter.rb

@@ -7,17 +7,29 @@ require 'json'
 
 module TwitterCldr
   module Formatters
-    class PluralFormatter < Base
+    class PluralFormatter
 
       PLURALIZATION_REGEXP = Regexp.union(
-          /%\{(\w+?):(\w+?)\}/,   # regular pluralization pattern
-          /%<(\{.*?\})>/          # inline pluralization pattern
+        /%\{(\w+?):(\w+?)\}/,   # regular pluralization pattern
+        /%<(\{.*?\})>/          # inline pluralization pattern
       )
 
-      attr_accessor :locale
+      class << self
+        def for_locale(locale)
+          formatter_cache[locale] ||= PluralFormatter.new(locale)
+        end
+
+        protected
+
+        def formatter_cache
+          @formatter_cache ||= {}
+        end
+      end
+
+      attr_reader :locale
 
-      def initialize(options = {})
-        self.locale = extract_locale(options)
+      def initialize(locale = TwitterCldr.locale)
+        @locale = TwitterCldr.convert_locale(locale)
       end
 
       # Replaces every pluralization token in the +string+ with a phrase formed using a number and a pluralization

data/lib/twitter_cldr/formatters.rb

@@ -5,11 +5,9 @@
 
 module TwitterCldr
   module Formatters
-    autoload :Base, 'twitter_cldr/formatters/base'
+    autoload :Formatter,                  'twitter_cldr/formatters/formatter'
 
-    autoload :DateTimeFormatter,          'twitter_cldr/formatters/calendars/datetime_formatter'
-    autoload :DateFormatter,              'twitter_cldr/formatters/calendars/date_formatter'
-    autoload :TimeFormatter,              'twitter_cldr/formatters/calendars/time_formatter'
+    autoload :DateTimeFormatter,          'twitter_cldr/formatters/calendars/date_time_formatter'
     autoload :TimespanFormatter,          'twitter_cldr/formatters/calendars/timespan_formatter'
 
     autoload :Numbers,                    'twitter_cldr/formatters/numbers'
@@ -20,10 +18,11 @@ module TwitterCldr
     autoload :LongDecimalFormatter,       'twitter_cldr/formatters/numbers/abbreviated/long_decimal_formatter'
     autoload :CurrencyFormatter,          'twitter_cldr/formatters/numbers/currency_formatter'
     autoload :PercentFormatter,           'twitter_cldr/formatters/numbers/percent_formatter'
+    autoload :Rbnf,                       'twitter_cldr/formatters/numbers/rbnf'
 
     autoload :Plurals,                    'twitter_cldr/formatters/plurals'
     autoload :PluralFormatter,            'twitter_cldr/formatters/plurals/plural_formatter'
 
     autoload :ListFormatter,              'twitter_cldr/formatters/list_formatter'
   end
-end
+end

data/lib/twitter_cldr/localized/localized_array.rb

@@ -31,7 +31,7 @@ module TwitterCldr
       end
 
       def to_sentence
-        TwitterCldr::Formatters::ListFormatter.new(:locale => locale).format(base_obj)
+        TwitterCldr::Formatters::ListFormatter.new(locale).format(base_obj)
       end
 
       def each

data/lib/twitter_cldr/localized/localized_date.rb

@@ -46,10 +46,13 @@ module TwitterCldr
         timezone_info.utc_to_local(time.is_a?(DateTime) ? time.new_offset(0) : time.utc)
       end
 
-      def formatter_const
-        TwitterCldr::Formatters::DateFormatter
+      def data_reader_for(type)
+        TwitterCldr::DataReaders::DateDataReader.new(locale, {
+          :calendar_type => calendar_type,
+          :type => type
+        })
       end
-    end
 
+    end
   end
 end

data/lib/twitter_cldr/localized/localized_datetime.rb

@@ -7,22 +7,42 @@ require 'tzinfo'
 
 module TwitterCldr
   module Localized
-
     class LocalizedDateTime < LocalizedObject
+
       attr_reader :calendar_type, :timezone
 
+      class << self
+        def types
+          TwitterCldr::DataReaders::CalendarDataReader::TYPE_PATHS.keys
+        end
+      end
+
       def initialize(obj, locale, options = {})
         super
         @calendar_type = options[:calendar_type] || TwitterCldr::DEFAULT_CALENDAR_TYPE
         @timezone = options[:timezone] || "UTC"
       end
 
-      TwitterCldr::Tokenizers::DateTimeTokenizer::VALID_TYPES.each do |format_type|
-        define_method "to_#{format_type}_s" do
-          @formatter.format(base_in_timezone, chain_params.merge(:type => format_type.to_sym))
+      types.each do |type|
+        define_method "to_#{type}_s" do
+          # @ TODO: these need to be cheap to create
+          data_reader = data_reader_for(type)
+          tokens = data_reader.tokenizer.tokenize(data_reader.pattern)
+          data_reader.formatter.format(tokens, base_in_timezone)
         end
       end
 
+      def to_additional_s(additional_format)
+        data_reader = data_reader_for(:additional, {
+          :additional_format => additional_format
+        })
+
+        tokens = data_reader.tokenizer.full_tokenize(data_reader.pattern)
+        data_reader.formatter.format(tokens, base_in_timezone)
+      end
+
+      alias :to_default_s :to_medium_s
+
       def to_timespan(options = {})
         base_time = options[:base_time] || Time.now
         seconds = (self.to_time.base_obj.to_i - base_time.to_i).abs
@@ -43,12 +63,12 @@ module TwitterCldr
         TwitterCldr::Localized::LocalizedTimespan.new(seconds, options.merge(:locale => @locale))
       end
 
-      def to_s(options = {})
-        if options[:format]
-          @formatter.format(base_in_timezone, options.merge(:type => :additional))
-        else
-          to_default_s
-        end
+      def additional_formats
+        data_reader_for(nil).additional_format_selector.patterns
+      end
+
+      def to_s
+        to_default_s
       end
 
       def to_date
@@ -77,6 +97,13 @@ module TwitterCldr
 
       protected
 
+      def data_reader_for(type, options = {})
+        TwitterCldr::DataReaders::DateTimeDataReader.new(locale, options.merge({
+          :calendar_type => calendar_type,
+          :type => type
+        }))
+      end
+
       def chain_params
         { :calendar_type => @calendar_type, :timezone => @timezone }
       end
@@ -85,14 +112,10 @@ module TwitterCldr
         timezone_info.utc_to_local(@base_obj.new_offset(0))
       end
 
-      def formatter_const
-        TwitterCldr::Formatters::DateTimeFormatter
-      end
-
       def timezone_info
         (@@timezone_info ||= {})[@timezone] ||= TZInfo::Timezone.get(@timezone)
       end
-    end
 
+    end
   end
 end

data/lib/twitter_cldr/localized/localized_number.rb

@@ -5,52 +5,68 @@
 
 module TwitterCldr
   module Localized
-
     class LocalizedNumber < LocalizedObject
-      DEFAULT_TYPE = :decimal
-      TYPES = [
-        :decimal,
-        :short_decimal,
-        :long_decimal,
-        :currency,
-        :percent,
-      ]
 
-      attr_reader :type
+      attr_reader :type, :format
 
       def initialize(obj, locale, options = {})
-        @options = options.dup
-
-        @type = @options.delete(:type) || DEFAULT_TYPE
-        raise ArgumentError.new("type #{@type} is not supported") unless @type && TYPES.include?(@type.to_sym)
+        @type = options[:type]
+        @format = options[:format]
+        super
+      end
 
-        super(obj, locale, @options)
+      class << self
+        def types
+          TwitterCldr::DataReaders::NumberDataReader::TYPE_PATHS.keys
+        end
       end
 
-      TYPES.each do |type|
+      types.each do |type|
         define_method "to_#{type}" do
           to_type(type)
         end
       end
 
       def to_s(options = {})
-        @formatter.format(@base_obj, options.merge(:type => @type))
+        data_reader = TwitterCldr::DataReaders::NumberDataReader.new(locale, {
+          :type => @type,
+          :format => @format
+        })
+
+        tokens = data_reader.tokenizer.tokenize(data_reader.pattern(base_obj))
+        data_reader.formatter.format(tokens, base_obj, options.merge(:type => @type))
       end
 
       def plural_rule
-        TwitterCldr::Formatters::Plurals::Rules.rule_for(@base_obj, @locale)
+        TwitterCldr::Formatters::Plurals::Rules.rule_for(base_obj, locale)
       end
 
-      protected
+      def spellout
+        rbnf.format(
+          base_obj, TwitterCldr::Formatters::Rbnf::RbnfFormatter::DEFAULT_SPELLOUT_OPTIONS
+        )
+      end
 
-      def formatter_const
-        TwitterCldr::Formatters.const_get("#{@type.to_s.split("_").map(&:capitalize).join}Formatter")
+      def to_rbnf_s(group_name, rule_set_name)
+        rbnf.format(base_obj, {
+          :rule_group => group_name,
+          :rule_set => rule_set_name
+        })
       end
 
+      def rbnf
+        @rbnf ||= TwitterCldr::Formatters::Rbnf::RbnfFormatter.new(locale)
+      end
+
+      protected
+
       def to_type(target_type)
-        self.class.new(@base_obj, @locale, @options.merge(:type => target_type))
+        self.class.new(base_obj, locale, {
+          :type => target_type,
+          :format => @format
+        })
       end
-    end
 
+    end
   end
-end
+end