twitter_cldr 1.6.2 → 1.7.0

data/js/lib/mustache/shared/currencies.coffee

@@ -0,0 +1,27 @@
+# Copyright 2012 Twitter, Inc
+# http://www.apache.org/licenses/LICENSE-2.0
+
+TwitterCldr.Currencies = class Currencies
+  @currencies = `{{{currencies}}}`
+
+  @countries: ->
+    @names ||= (country_name for country_name, data of @currencies)
+
+  @currency_codes: ->
+    @codes ||= (data.code for country_name, data of @currencies)
+
+  @for_country: (country_name) ->
+    @currencies[country_name]
+
+  @for_code: (currency_code) ->
+    final = null
+    for country_name, data of @currencies
+      if data.code == currency_code
+        final =
+          country: country_name
+          code: data.code
+          symbol: data.symbol
+          currency: data.currency
+        break
+
+    final

data/js/lib/renderers/numbers/numbers_renderer.rb

@@ -0,0 +1,31 @@
+# encoding: UTF-8
+
+# Copyright 2012 Twitter, Inc
+# http://www.apache.org/licenses/LICENSE-2.0
+
+module TwitterCldr
+  module Js
+    module Renderers
+      module Numbers
+        class NumbersRenderer < TwitterCldr::Js::Renderers::Base
+          self.template_file = File.expand_path(File.join(File.dirname(__FILE__), "../..", "mustache/numbers/numbers.coffee"))
+
+          def tokens
+            TwitterCldr::Tokenizers::NumberTokenizer::VALID_TYPES.inject({}) do |ret, type|
+              tokenizer = TwitterCldr::Tokenizers::NumberTokenizer.new(:type => type, :locale => @locale)
+              ret[type] = {}
+              [:positive, :negative].each do |sign|
+                ret[type][sign] = tokenizer.tokens(:sign => sign)
+              end
+              ret
+            end.to_json
+          end
+
+          def symbols
+            TwitterCldr::Tokenizers::NumberTokenizer.new(:locale => @locale).symbols.to_json
+          end
+        end
+      end
+    end
+  end
+end

data/js/lib/renderers/plurals/rules/plural_rules_compiler.rb

@@ -44,6 +44,10 @@ module TwitterCldr
                   "#{statement_list(tree[1])} #{tree[2]} #{statement_list(tree[3])}"
                 when :include?
                   "#{statement_list(tree[1])}.indexOf(#{statement_list(tree[3])}) >= 0"
+                when :between?
+                  smt = "((#{statement_list(tree[1])} >= #{statement_list(tree[3][1])})"
+                  smt << " && (#{statement_list(tree[1])} <= #{statement_list(tree[3][2])}))"
+                  smt
                 else
                   # this should be the only case where tree[1] might be nil (i.e. the method was not called on any object)
                   call = tree[1] ? "#{statement_list(tree[1])}.#{tree[2]}" : tree[2].to_s
@@ -58,7 +62,7 @@ module TwitterCldr
 
             def _lit(tree)
               if tree[1].is_a?(Symbol) || tree[1].is_a?(String)
-                "\"#{tree[1]}\""
+                %Q("#{tree[1]}")
               else
                 tree[1]
               end

data/js/lib/renderers/shared/currencies_renderer.rb

@@ -0,0 +1,23 @@
+# encoding: UTF-8
+
+# Copyright 2012 Twitter, Inc
+# http://www.apache.org/licenses/LICENSE-2.0
+
+module TwitterCldr
+  module Js
+    module Renderers
+      module Shared
+        class CurrenciesRenderer < TwitterCldr::Js::Renderers::Base
+          self.template_file = File.expand_path(File.join(File.dirname(__FILE__), "../..", "mustache/shared/currencies.coffee"))
+
+          def currencies
+            TwitterCldr::Shared::Currencies.countries.inject({}) do |ret, country_name|
+              ret[country_name] = TwitterCldr::Shared::Currencies.for_country(country_name)
+              ret
+            end.to_json
+          end
+        end
+      end
+    end
+  end
+end

data/js/lib/twitter_cldr_js.rb

@@ -18,6 +18,8 @@ require 'renderers/base'
 
 require 'renderers/calendars/datetime_renderer'
 require 'renderers/calendars/timespan_renderer'
+require 'renderers/numbers/numbers_renderer'
+require 'renderers/shared/currencies_renderer'
 require 'renderers/plurals/rules/plural_rules_compiler'
 require 'renderers/plurals/rules/plural_rules_renderer'
 

data/js/spec/js/calendars/timespan_spec.js

@@ -15,7 +15,7 @@ describe("TimespanFormatter", function() {
         direction: "none"
       })).toEqual('0 years');
       expect(formatter.format(3273932, {
-        unit: "month"
+        unit: "month",
         direction: "none",
       })).toEqual('1 month');
       expect(formatter.format(3273932, {
@@ -38,7 +38,7 @@ describe("TimespanFormatter", function() {
         unit: "second",
         direction: "none"
       })).toEqual('3273932 seconds');
-    }),
+    });
 
     it("works for a variety of units in the past", function() {
       expect(formatter.format(-3273932, {

data/js/spec/js/numbers/currency_spec.js

@@ -0,0 +1,34 @@
+// Copyright 2012 Twitter, Inc
+// http://www.apache.org/licenses/LICENSE-2.0
+
+//= require '../../../build/twitter_cldr_en.js'
+
+describe("CurrencyFormatter", function() {
+  describe("#format", function() {
+    beforeEach(function() {
+      formatter = new TwitterCldr.CurrencyFormatter();
+    });
+
+    it("should use a dollar sign when no other currency symbol is given (and default to a precision of 2)", function() {
+      expect(formatter.format(12)).toEqual("$12.00");
+    });
+
+    it("handles negative numbers", function() {
+      // yes, the parentheses really are part of the format, don't worry about it
+      expect(formatter.format(-12)).toEqual("-($12.00)");
+    });
+
+    it("should use the specified currency symbol when specified", function() {
+      // S/. is the symbol for the Peruvian Nuevo Sol, just in case you were curious
+      expect(formatter.format(12, {currency: "S/."})).toEqual("S/.12.00");
+    });
+
+    it("should use the currency symbol for the corresponding currency code", function() {
+      expect(formatter.format(12, {currency: "PEN"})).toEqual("S/.12.00");
+    });
+
+    it("overrides the default precision", function() {
+      expect(formatter.format(12, {precision: 3})).toEqual("$12.000");
+    });
+  });
+});

data/js/spec/js/numbers/decimal_spec.js

@@ -0,0 +1,24 @@
+// Copyright 2012 Twitter, Inc
+// http://www.apache.org/licenses/LICENSE-2.0
+
+//= require '../../../build/twitter_cldr_en.js'
+
+describe("DecimalFormatter", function() {
+  beforeEach(function() {
+    formatter = new TwitterCldr.DecimalFormatter();
+  });
+
+  describe("#format", function() {
+    it("should format positive decimals correctly", function() {
+      expect(formatter.format(12.1)).toEqual("12.1");
+    });
+
+    it("should format negative decimals correctly", function() {
+      expect(formatter.format(-12.1)).toEqual("-12.1");
+    });
+
+    it("should respect the precision option", function() {
+      expect(formatter.format(-12, {precision: 3})).toEqual("-12.000");
+    });
+  });
+});

data/js/spec/js/numbers/helpers/fraction_spec.js

@@ -0,0 +1,23 @@
+// Copyright 2012 Twitter, Inc
+// http://www.apache.org/licenses/LICENSE-2.0
+
+//= require '../../../../build/twitter_cldr_en.js'
+
+describe("FractionHelper", function() {
+  describe("#apply", function() {
+    it("test: formats a fraction", function() {
+      var token = '###.##';
+      expect(new TwitterCldr.NumberFormatter.FractionHelper(token).apply('45')).toEqual('.45');
+    });
+
+    it("test: pads zero digits on the right side", function() {
+      var token = '###.0000#';
+      expect(new TwitterCldr.NumberFormatter.FractionHelper(token).apply('45')).toEqual('.45000');
+    });
+
+    it("test: :precision option overrides format precision", function() {
+      var token = '###.##';
+      expect(new TwitterCldr.NumberFormatter.FractionHelper(token).apply('78901', {precision: 5})).toEqual('.78901');
+    });
+  });
+});

data/js/spec/js/numbers/helpers/integer_spec.js

@@ -0,0 +1,100 @@
+// Copyright 2012 Twitter, Inc
+// http://www.apache.org/licenses/LICENSE-2.0
+
+//= require '../../../../build/twitter_cldr_en.js'
+
+describe("IntegerHelper", function() {
+  describe("#apply", function() {
+    describe("with the ### format", function() {
+      beforeEach(function() {
+        token = "###";
+      });
+
+      it("test: interpolates a number", function() {
+        expect(new TwitterCldr.NumberFormatter.IntegerHelper(token).apply(123)).toEqual('123');
+      });
+
+      it("test: does not include a fraction for a float", function() {
+        expect(new TwitterCldr.NumberFormatter.IntegerHelper(token).apply(123.45)).toEqual('123');
+      });
+
+      it("test: does not round when given a float", function() {
+        expect(new TwitterCldr.NumberFormatter.IntegerHelper(token).apply(123.55)).toEqual('123');
+      });
+
+      it("test: does not round with :precision => 1", function() {
+        expect(new TwitterCldr.NumberFormatter.IntegerHelper(token).apply(123.55, {precision: 1})).toEqual('123');
+      });
+    });
+
+    describe("with the #,## format", function() {
+      beforeEach(function() {
+        token = "#,##";
+      });
+
+      it("test: single group", function() {
+        expect(new TwitterCldr.NumberFormatter.IntegerHelper(token).apply(123)).toEqual('1,23');
+      });
+
+      it("test: multiple groups with a primary group size", function() {
+        expect(new TwitterCldr.NumberFormatter.IntegerHelper(token).apply(123456789)).toEqual('1,23,45,67,89');
+      });
+    });
+
+    describe("with the #,##0.## format", function() {
+      beforeEach(function() {
+        token = "#,##0.##";
+      });
+
+      it("test: ignores a fraction part given in the format string", function() {
+        expect(new TwitterCldr.NumberFormatter.IntegerHelper(token).apply(1234.567)).toEqual('1,234');
+      });
+
+      it("test: cldr example #,##0.## => 1 234", function() {
+        expect(new TwitterCldr.NumberFormatter.IntegerHelper(token).apply(1234.567)).toEqual('1,234');
+      });
+    });
+
+    describe("miscellaneous formats", function() {
+      it("test: interpolates a number on the right side", function () {
+        token = "0###";
+        expect(new TwitterCldr.NumberFormatter.IntegerHelper(token).apply(123)).toEqual('0123');
+      });
+
+      it("test: strips optional digits", function() {
+        token = "######";
+        expect(new TwitterCldr.NumberFormatter.IntegerHelper(token).apply(123)).toEqual('123');
+      });
+
+      it("test: multiple groups with a primary and secondary group size", function() {
+        token = "#,##,##0";
+        expect(new TwitterCldr.NumberFormatter.IntegerHelper(token).apply(123456789)).toEqual('12,34,56,789');
+      });
+
+      it("test: does not group when no digits left of the grouping position", function() {
+        token = "#,###";
+        expect(new TwitterCldr.NumberFormatter.IntegerHelper(token).apply(123)).toEqual('123');
+      });
+
+      it("test: cldr example #,##0.### => 1 234", function() {
+        token = "#,##0.###";
+        expect(new TwitterCldr.NumberFormatter.IntegerHelper(token, {group: ' '}).apply(1234.567)).toEqual('1 234');
+      });
+
+      it("test: cldr example ###0.##### => 1234", function() {
+        token = "###0.#####";
+        expect(new TwitterCldr.NumberFormatter.IntegerHelper(token, {group: ' '}).apply(1234.567)).toEqual('1234');
+      });
+
+      it("test: cldr example ###0.0000# => 1234", function() {
+        token = "###0.0000#";
+        expect(new TwitterCldr.NumberFormatter.IntegerHelper(token, {group: ' '}).apply(1234.567)).toEqual('1234');
+      });
+
+      it("test: cldr example 00000.0000 => 01234", function() {
+        token = "00000.0000";
+        expect(new TwitterCldr.NumberFormatter.IntegerHelper(token, {group: ' '}).apply(1234.567)).toEqual('01234');
+      });
+    });
+  });
+});

data/js/spec/js/numbers/number_spec.js

@@ -0,0 +1,70 @@
+// Copyright 2012 Twitter, Inc
+// http://www.apache.org/licenses/LICENSE-2.0
+
+//= require '../../../build/twitter_cldr_en.js'
+
+describe("NumberFormatter", function() {
+  beforeEach(function() {
+    formatter = new TwitterCldr.DecimalFormatter();
+  });
+
+  describe("#precision_from", function() {
+    it("should return the correct precision", function() {
+      expect(formatter.precision_from(12.123)).toEqual(3);
+    });
+
+    it("should return zero precision if the number isn't a decimal", function() {
+      expect(formatter.precision_from(12)).toEqual(0);
+    });
+  });
+
+  describe("#round_to", function() {
+    it("should round a number to the given precision", function() {
+      expect(formatter.round_to(12, 0)).toEqual(12);
+      expect(formatter.round_to(12.2, 0)).toEqual(12);
+      expect(formatter.round_to(12.5, 0)).toEqual(13);
+      expect(formatter.round_to(12.25, 1)).toEqual(12.3);
+      expect(formatter.round_to(12.25, 2)).toEqual(12.25);
+      expect(formatter.round_to(12.25, 3)).toEqual(12.25);
+    });
+  });
+
+  describe("#parse_number", function() {
+    it("should round and split the given number by decimal", function() {
+      expect(formatter.parse_number(12, {precision: 0})).toEqual(["12"]);
+      expect(formatter.parse_number(12.2, {precision: 0})).toEqual(["12"]);
+      expect(formatter.parse_number(12.5, {precision: 0})).toEqual(["13"]);
+      expect(formatter.parse_number(12.25, {precision: 1})).toEqual(["12", "3"]);
+      expect(formatter.parse_number(12.25, {precision: 2})).toEqual(["12", "25"]);
+      expect(formatter.parse_number(12.25, {precision: 3})).toEqual(["12", "250"]);
+    });
+  });
+
+  describe("#format", function() {
+    it("should format a basic integer", function() {
+      expect(formatter.format(12)).toEqual("12");
+    });
+
+    describe("should respect the :precision option", function() {
+      it("formats with precision of 0", function() {
+        expect(formatter.format(12.1, {precision: 0})).toEqual("12");
+      });
+
+      it("rounds and formats with precision of 1", function() {
+        expect(formatter.format(12.25, {precision: 1})).toEqual("12.3");
+      });
+    });
+
+    it("uses the length of the original decimal as the precision", function() {
+      expect(formatter.format(12.8543)).toEqual("12.8543");
+    });
+
+    it("formats an integer larger than 999", function() {
+      expect(formatter.format(1337)).toEqual("1,337");
+    });
+
+    it("formats a decimal larger than 999.9", function() {
+      expect(formatter.format(1337.37)).toEqual("1,337.37");
+    });
+  });
+});

data/js/spec/js/numbers/percent_spec.js

@@ -0,0 +1,22 @@
+// Copyright 2012 Twitter, Inc
+// http://www.apache.org/licenses/LICENSE-2.0
+
+//= require '../../../build/twitter_cldr_en.js'
+
+describe("PercentFormatter", function() {
+  beforeEach(function() {
+    formatter = new TwitterCldr.PercentFormatter();
+  });
+
+  it("should format the number correctly", function() {
+    expect(formatter.format(12)).toEqual("12%");
+  });
+
+  it("should format negative numbers correctly", function() {
+    expect(formatter.format(-12)).toEqual("-12%");
+  });
+
+  it("should respect the precision option", function() {
+    expect(formatter.format(-12, {precision: 3})).toEqual("-12.000%");
+  });
+});

data/js/spec/rb/renderers/plurals/plural_rules_compiler_spec.rb

@@ -21,6 +21,10 @@ describe PluralRulesCompiler do
       PluralRulesCompiler.rule_to_js("[2, 3, 4].include?(n)").should == "function(n) { return [2, 3, 4].indexOf(n) >= 0 }"
     end
 
+    it "handles a between? call" do
+      PluralRulesCompiler.rule_to_js("n.between?(0, 2)").should == "function(n) { return ((n >= 0) && (n <= 2)) }"
+    end
+
     it "handles the modulus operator" do
       PluralRulesCompiler.rule_to_js("n % 10").should == "function(n) { return n % 10 }"
     end

data/lib/twitter_cldr/collation/collator.rb

@@ -37,10 +37,10 @@ module TwitterCldr
       end
 
       def get_collation_elements(string_or_code_points)
-        integer_code_points = get_normalized_code_points(string_or_code_points)
+        code_points = get_normalized_code_points(string_or_code_points)
 
         result = []
-        result.concat(code_point_collation_elements(integer_code_points)) until integer_code_points.empty?
+        result.concat(code_point_collation_elements(code_points)) until code_points.empty?
         result
       end
 
@@ -54,19 +54,13 @@ module TwitterCldr
         @locale ? self.class.tailored_trie(@locale) : self.class.default_trie
       end
 
-      def get_integer_code_points(code_points)
-        code_points.map { |code_point| code_point.to_i(16) }
-      end
-
       def get_normalized_code_points(str_or_code_points)
         code_points = str_or_code_points.is_a?(String) ? TwitterCldr::Utils::CodePoints.from_string(str_or_code_points) : str_or_code_points
 
         # Normalization makes the collation process significantly slower (like seven times slower on the UCA
         # non-ignorable test from CollationTest_NON_IGNORABLE.txt). ICU uses some optimizations to apply normalization
         # only in special, rare cases. We need to investigate possible solutions and do normalization cleverly too.
-        code_points = TwitterCldr::Normalization::NFD.normalize_code_points(code_points)
-
-        get_integer_code_points(code_points)
+        TwitterCldr::Normalization::NFD.normalize_code_points(code_points)
       end
 
       # Returns the first sequence of fractional collation elements for an array of integer code points. Returned value
@@ -74,8 +68,8 @@ module TwitterCldr
       #
       # NOTE (side-effect): all used code points are removed from the input array.
       #
-      def code_point_collation_elements(integer_code_points)
-        explicit_collation_elements(integer_code_points) || implicit_collation_elements(integer_code_points)
+      def code_point_collation_elements(code_points)
+        explicit_collation_elements(code_points) || implicit_collation_elements(code_points)
       end
 
       # Tries to build explicit collation elements array for the longest code points prefix in the given sequence. When
@@ -87,23 +81,23 @@ module TwitterCldr
       #
       # For more information see section '4.2 Produce Array' of the main algorithm at http://www.unicode.org/reports/tr10/#Main_Algorithm
       #
-      def explicit_collation_elements(integer_code_points)
+      def explicit_collation_elements(code_points)
         # find the longest prefix in the trie
-        collation_elements, prefix_size, suffixes = @trie.find_prefix(integer_code_points)
+        collation_elements, prefix_size, suffixes = @trie.find_prefix(code_points)
 
         return unless collation_elements
 
         # remove prefix from the code points sequence
-        integer_code_points.shift(prefix_size)
+        code_points.shift(prefix_size)
 
         non_starter_pos = 0
 
         used_combining_classes = {}
 
-        while non_starter_pos < integer_code_points.size && !suffixes.empty?
+        while non_starter_pos < code_points.size && !suffixes.empty?
           # get next code point (possibly non-starter)
-          non_starter_code_point = integer_code_points[non_starter_pos]
-          combining_class        = TwitterCldr::Normalization::Base.combining_class_for(non_starter_code_point.to_s(16))
+          non_starter_code_point = code_points[non_starter_pos]
+          combining_class        = TwitterCldr::Normalization::Base.combining_class_for(non_starter_code_point)
 
           # code point is a starter or combining class has been already used (non-starter is 'blocked' from the prefix)
           break if combining_class == 0 || used_combining_classes[combining_class]
@@ -120,7 +114,7 @@ module TwitterCldr
             suffixes           = new_suffixes
 
             # Remove non-starter from its position in the sequence. Then we can move further from the same position.
-            integer_code_points.delete_at(non_starter_pos)
+            code_points.delete_at(non_starter_pos)
           else
             # move to the next code point
             non_starter_pos += 1
@@ -130,8 +124,8 @@ module TwitterCldr
         collation_elements
       end
 
-      def implicit_collation_elements(integer_code_points)
-        TwitterCldr::Collation::ImplicitCollationElements.for_code_point(integer_code_points.shift)
+      def implicit_collation_elements(code_points)
+        TwitterCldr::Collation::ImplicitCollationElements.for_code_point(code_points.shift)
       end
 
       class << self