twitter_cldr_js 2.2.0 → 2.2.2

data/lib/twitter_cldr/js/compiler.rb

@@ -3,8 +3,14 @@
 # Copyright 2012 Twitter, Inc
 # http://www.apache.org/licenses/LICENSE-2.0
 
+require 'mustache'
+require 'uglifier'
+require 'coffee-script'
+
 module TwitterCldr
   module Js
+    CompiledFile = Struct.new(:source, :source_map)
+
     class Compiler
       attr_reader :locales
 
@@ -12,6 +18,7 @@ module TwitterCldr
         @locales = options[:locales] || TwitterCldr.supported_locales
         @features = options[:features] || renderers.keys
         @prerender = options[:prerender].nil? ? true : options[:prerender]
+        @source_map = options[:source_map]
       end
 
       def compile_each(options = {})
@@ -28,13 +35,24 @@ module TwitterCldr
           bundle = TwitterCldr::Js::Renderers::Bundle.new
           bundle[:locale] = locale
           bundle[:contents] = contents
-          result = CoffeeScript.compile(bundle.render, :bare => false)
+          bundle[:source_map] = @source_map
+
+          result = CoffeeScript.compile(bundle.render, {
+            :bare => false,
+            :sourceMap => @source_map
+          })
+
+          file = if @source_map
+            CompiledFile.new(result["js"], result["sourceMap"])
+          else
+            CompiledFile.new(result)
+          end
 
           # required alias definition that adds twitter_cldr to Twitter's static build process
-          result.gsub!(/\/\*<<module_def>>\s+\*\//, %Q(/*-module-*/\n/*_lib/twitter_cldr_*/))
-          result = Uglifier.compile(result) if options[:minify]
+          file.source.gsub!(/\/\*<<module_def>>\s+\*\//, %Q(/*-module-*/\n/*_lib/twitter_cldr_*/))
+          file.source = Uglifier.compile(file.source) if options[:minify]
 
-          yield result, TwitterCldr.twitter_locale(locale)
+          yield file, TwitterCldr.twitter_locale(locale)
         end
       end
 
@@ -50,7 +68,8 @@ module TwitterCldr
           :currencies => TwitterCldr::Js::Renderers::Shared::CurrenciesRenderer,
           :lists => TwitterCldr::Js::Renderers::Shared::ListRenderer,
           :bidi => TwitterCldr::Js::Renderers::Shared::BidiRenderer,
-          :calendar => TwitterCldr::Js::Renderers::Shared::CalendarRenderer
+          :calendar => TwitterCldr::Js::Renderers::Shared::CalendarRenderer,
+          :number_parser => TwitterCldr::Js::Renderers::Parsers::NumberParser
         }
       end
     end

data/lib/twitter_cldr/js/mustache/bundle.coffee

@@ -10,6 +10,12 @@
 // Description: Provides date, time, number, and list formatting functionality for various Twitter-supported locales in Javascript.
 ###
 
+{{#source_map}}
+###
+//@ sourceMappingURL={{locale}}.map
+###
+{{/source_map}}
+
 # required alias definition that adds twitter_cldr to Twitter's static build process
 ###<<module_def>>###
 

data/lib/twitter_cldr/js/mustache/parsers/number_parser.coffee

@@ -0,0 +1,103 @@
+# Copyright 2012 Twitter, Inc
+# http://www.apache.org/licenses/LICENSE-2.0
+
+class TwitterCldr.NumberParser
+  constructor: ->
+    @group_separator = "{{{group_separator}}}"
+    @decimal_separator = "{{{decimal_separator}}}"
+    @separator_chars = ['\\.', ',', '\\s'].join("")
+
+  parse: (number_text, options = {}) ->
+    options.strict = true if options.strict is undefined
+    separators = this.get_separators(options.strict)
+    tokens = this.tokenize(number_text, separators.group, separators.decimal)
+    num_list = []
+    punct_list = []
+
+    for token in tokens
+      if token.type == "numeric"
+        num_list.push(token)
+      else
+        punct_list.push(token)
+
+    throw "Invalid number" unless this.is_punct_valid(punct_list)
+    throw "Invalid number" unless tokens.slice(-1)[0] &&
+      tokens.slice(-1)[0]["type"] == "numeric"
+
+    if punct_list.length > 0 && punct_list.slice(-1)[0]["type"] == "decimal"
+      result = parseInt((num.value for num in num_list[0..-2]).join("")) || 0
+      last = num_list.slice(-1)[0];
+      result + parseInt(last.value) / Math.pow(10.0, last.value.length)
+    else
+      parseInt((num.value for num in num_list).join(""))
+
+  try_parse: (number_text, default_value = null, callback = null, options = {}) ->
+    result = try
+      this.parse(number_text, options)
+    catch err
+      if err.toString() == "Invalid number"
+        null
+      else
+        throw err
+
+    if callback
+      callback(result)
+    else
+      result || default_value
+
+  is_valid: (number_text, options = {}) ->
+    try
+      this.parse(number_text, options)
+      true
+    catch err
+      if err.toString() == "Invalid number"
+        false
+      else
+        throw err
+
+  @is_numeric: (text, separators) ->
+    unless separators?
+      separators = new NumberParser().separator_chars
+
+    regexp = new RegExp("^[0-9" + separators + "]+$")
+    regexp.test(text)
+
+  is_punct_valid: (punct_list) ->
+    # all group, allowed one decimal at end
+    valid = true
+
+    for punct, index in punct_list
+      valid = valid && (punct.type == "group" ||
+        (index == (punct_list.length - 1) && punct.type == "decimal")
+      )
+
+    valid
+
+  get_separators: (strict = false) ->
+    group = if strict then @group_separator else @separator_chars
+    decimal = if strict then @decimal_separator else @separator_chars
+    { group: group, decimal: decimal }
+
+  tokenize: (number_text, group, decimal) ->
+    regexp = new RegExp("([\\d]*)([" + group + "]{0,1})([\\d]*)([" + decimal + "]{0,1})([\\d]*)")
+    match_data = number_text.split(regexp)
+    match_data = (match for match in match_data when match != "")
+    tokens = (this.identify(match, group, decimal) for match in match_data)
+    token for token in tokens when token.type != null
+
+  identify: (text, group, decimal) ->
+    result = { value: text }
+    result.type = if NumberParser.is_numeric(result.value, "")
+      "numeric"
+    else
+      group_regexp = new RegExp("[" + group + "]")
+      decimal_regexp = new RegExp("[" + decimal + "]")
+
+      if group_regexp.test(result.value)
+        "group"
+      else if decimal_regexp.test(result.value)
+        "decimal"
+      else
+        null
+
+    result

data/lib/twitter_cldr/js/renderers/base.rb

@@ -8,6 +8,8 @@ module TwitterCldr
     module Renderers
       class Base < Mustache
 
+        attr_reader :locale
+
         def initialize(options = {})
           @locale = options[:locale]
         end

data/lib/twitter_cldr/js/renderers/parsers/number_parser.rb

@@ -0,0 +1,34 @@
+# encoding: UTF-8
+
+# Copyright 2012 Twitter, Inc
+# http://www.apache.org/licenses/LICENSE-2.0
+
+module TwitterCldr
+  module Js
+    module Renderers
+      module Parsers
+
+        class NumberParser < TwitterCldr::Js::Renderers::Base
+          self.template_file = File.expand_path(
+            File.join(File.dirname(__FILE__), "../..", "mustache/parsers/number_parser.coffee")
+          )
+
+          def group_separator
+            Regexp.escape(parser.send(:group_separator))
+          end
+
+          def decimal_separator
+            Regexp.escape(parser.send(:decimal_separator))
+          end
+
+          private
+
+          def parser
+            @parser = TwitterCldr::Parsers::NumberParser.new(locale)
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/twitter_cldr/js/renderers.rb

@@ -30,6 +30,10 @@ module TwitterCldr
         autoload :BidiRenderer,                         'twitter_cldr/js/renderers/shared/bidi_renderer'
         autoload :CalendarRenderer,                     'twitter_cldr/js/renderers/shared/calendar_renderer'
       end
+
+      module Parsers
+        autoload :NumberParser,                         'twitter_cldr/js/renderers/parsers/number_parser'
+      end
     end
   end
 end

data/lib/twitter_cldr/js/tasks/tasks.rb

@@ -30,8 +30,13 @@ module TwitterCldr
           locales = get_locales
           $stdout.write(options[:begin_msg])
 
-          prerender  = ENV["PRERENDER"] ? ENV["PRERENDER"] == "true" : nil
-          compiler   = TwitterCldr::Js::Compiler.new(:locales => locales, :prerender => prerender)
+          compiler_options = {
+            :locales => locales,
+            :prerender => ENV["PRERENDER"] ? ENV["PRERENDER"] == "true" : nil,
+            :source_map => ENV["SOURCE_MAP"] ? ENV["SOURCE_MAP"] == "true" : false
+          }
+
+          compiler   = TwitterCldr::Js::Compiler.new(compiler_options)
           output_dir = File.expand_path(options[:output_dir] || get_output_dir)
 
           build_duration = time_operation do
@@ -40,7 +45,14 @@ module TwitterCldr
                 out_file = File.join(output_dir, file_pattern % locale)
                 FileUtils.mkdir_p(File.dirname(out_file))
                 File.open(out_file, "w+") do |f|
-                  f.write(bundle)
+                  f.write(bundle.source)
+                end
+
+                if bundle.source_map
+                  ext = File.extname(out_file)
+                  File.open("#{out_file.chomp(ext)}.map", "w+") do |f|
+                    f.write(bundle.source_map)
+                  end
                 end
               end
             end

data/lib/twitter_cldr/js/version.rb

@@ -5,6 +5,6 @@
 
 module TwitterCldr
   module Js
-    VERSION = "2.2.0"
+    VERSION = "2.2.2"
   end
-end
+end

data/lib/twitter_cldr/js.rb

@@ -5,10 +5,7 @@
 
 require 'rails'
 require 'twitter_cldr'
-require 'mustache'
 require 'json'
-require 'uglifier'
-require 'coffee-script'
 require 'rake'
 
 require 'twitter_cldr/js/version'

data/spec/js/parsers/number_parser.spec.js

@@ -0,0 +1,211 @@
+// Copyright 2012 Twitter, Inc
+// http://www.apache.org/licenses/LICENSE-2.0
+
+var TwitterCldr = require('../../../lib/assets/javascripts/twitter_cldr/en.js');
+
+describe("NumberParser", function() {
+  beforeEach(function() {
+    separators = [",", "\\."]
+    parser = new TwitterCldr.NumberParser();
+  });
+
+  describe("#group_separator", function() {
+    it("returns the correct group separator", function() {
+      expect(parser.group_separator).toEqual(",");
+    });
+  });
+
+  describe("#decimal_separator", function() {
+    it("returns the correct decimal separator", function() {
+      expect(parser.decimal_separator).toEqual("\\\.");
+    });
+  });
+
+  describe("#identify", function() {
+    it("properly identifies a numeric value", function() {
+      expect(
+        parser.identify("7841", separators[0], separators[1])
+      ).toEqual({value: "7841", type: "numeric"});
+    });
+
+    it("properly identifies a decimal separator", function() {
+      expect(
+        parser.identify(".", separators[0], separators[1])
+      ).toEqual({value: ".", type: "decimal"});
+    });
+
+    it("properly identifies a group separator", function() {
+      expect(
+        parser.identify(",", separators[0], separators[1])
+      ).toEqual({value: ",", type: "group"});
+    });
+
+    it("returns nil if the text doesn't match a number or either separators", function() {
+      expect(
+        parser.identify("abc", separators[0], separators[1])
+      ).toEqual({value: "abc", type: null});
+    });
+  });
+
+  describe("#tokenize", function() {
+    it("splits text by numericality and group/decimal separators", function() {
+      expect(
+        parser.tokenize("1,33.00", separators[0], separators[1])
+      ).toEqual([
+        {value: "1",  type: "numeric"},
+        {value: ",",  type: "group"},
+        {value: "33", type: "numeric"},
+        {value: ".",  type: "decimal"},
+        {value: "00", type: "numeric"}
+      ]);
+    });
+
+    it("returns an empty array for a non-numeric string", function() {
+      expect(parser.tokenize("abc", separators[0], separators[1])).toEqual([]);
+    });
+  });
+
+  describe("#get_separators", function() {
+    it("returns all separators when strict mode is off", function() {
+      var found_separators = parser.get_separators(false);
+      expect(found_separators.group).toEqual('\\.,\\s');
+      expect(found_separators.decimal).toEqual('\\.,\\s');
+    });
+
+    it("returns only locale-specific separators when strict mode is on", function() {
+      var found_separators = parser.get_separators(true);
+      expect(found_separators.group).toEqual(',');
+      expect(found_separators.decimal).toEqual('\\.');
+    });
+  });
+
+  describe("#is_punct_valid", function() {
+    function strip_numerics(token_list) {
+      var tokens = [];
+
+      for (var idx in token_list) {
+        if (token_list[idx].type != "numeric") {
+          tokens.push(token_list[idx]);
+        }
+      }
+
+      return tokens;
+    }
+
+    it("correctly validates a number with no decimal", function() {
+      var tokens = strip_numerics(parser.tokenize("1.337", separators[0], separators[1]));
+      expect(parser.is_punct_valid(tokens)).toEqual(true);
+    });
+
+    it("correctly validates a number with a decimal", function() {
+      var tokens = strip_numerics(parser.tokenize("1,337.00", separators[0], separators[1]));
+      expect(parser.is_punct_valid(tokens)).toEqual(true);
+    });
+
+    it("reports on an invalid number when it has more than one decimal", function() {
+      var tokens = strip_numerics(parser.tokenize("1.337.00", separators[0], separators[1]));
+      expect(parser.is_punct_valid(tokens)).toEqual(false);
+    });
+  });
+
+  describe("#is_numeric?", function() {
+    it("returns true if the text is numeric", function() {
+      expect(TwitterCldr.NumberParser.is_numeric("4839", "")).toEqual(true);
+      expect(TwitterCldr.NumberParser.is_numeric("1", "")).toEqual(true);
+    });
+
+    it("returns false if the text is not purely numeric", function() {
+      expect(TwitterCldr.NumberParser.is_numeric("abc", "")).toEqual(false);
+      expect(TwitterCldr.NumberParser.is_numeric("123abc", "")).toEqual(false);
+    });
+
+    it("returns false if the text is blank", function() {
+      expect(TwitterCldr.NumberParser.is_numeric("", "")).toEqual(false);
+    });
+
+    it("accepts the given characters as valid numerics", function() {
+      expect(TwitterCldr.NumberParser.is_numeric("a123a", "a")).toEqual(true);
+      expect(TwitterCldr.NumberParser.is_numeric("1,234.56")).toEqual(true);  // default separator chars used here
+    });
+  });
+
+  describe("#valid?", function() {
+    it("correctly identifies a series of valid cases", function() {
+      var nums = ["5", "5.0", "1,337", "1,337.0", "0.05", ".5", "1,337,000.00"];
+      for (var idx in nums) {
+        expect(parser.is_valid(nums[idx])).toEqual(true);
+      }
+    });
+
+    it("correctly identifies a series of invalid cases", function() {
+      var nums = ["12.0.0", "5.", "5,"];
+      for (var idx in nums) {
+        expect(parser.is_valid(nums[idx])).toEqual(false);
+      }
+    });
+  });
+
+  describe("#parse", function() {
+    it("correctly parses a series of valid numbers", function() {
+      var cases = {
+        "5": 5,
+        "5.0": 5.0,
+        "1,337": 1337,
+        "1,337.0": 1337.0,
+        "0.05": 0.05,
+        ".5": 0.5,  // Borked
+        "1,337,000.00": 1337000.0
+      };
+
+      for (var text in cases) {
+        var expected = cases[text];
+        expect(parser.parse(text)).toEqual(expected);
+      }
+    });
+
+    it("correctly raises an error when asked to parse invalid numbers", function() {
+      var cases = ["12.0.0", "5.", "5,"];
+
+      for (var idx in cases) {
+        expect(function() {
+          parser.parse(cases[idx])
+        }).toThrow(new Error("Invalid number"));
+      }
+    });
+
+    describe("non-strict", function() {
+      it("succeeds in parsing even if inexact punctuation is used", function() {
+        expect(parser.parse("5 100", {strict: false})).toEqual(5100);
+      });
+    });
+  });
+
+  describe("#try_parse", function() {
+    it("parses correctly with a valid number", function() {
+      expect(parser.try_parse("1,234")).should == 1234;
+    });
+
+    it("parses correctly with a valid number and calls the callback", function() {
+      var pre_result = null;
+      parser.try_parse("1,234", null, function(result) { pre_result = result; });
+      pre_result.should == 1234
+    });
+
+    it("falls back on the default value if the number is invalid", function() {
+      expect(parser.try_parse("5.")).toEqual(null);
+      expect(parser.try_parse("5.", 0)).toEqual(0);
+    });
+
+    it("falls back on the block if the number is invalid", function() {
+      var pre_result = null;
+      parser.try_parse("5.", null, function(result) { pre_result = 9 });
+      expect(pre_result).toEqual(9);
+    });
+
+    it("re-raises any unexpected errors", function() {
+      expect(function() {
+        parser.try_parse({});
+      }).toThrow(new Error("Object #<Object> has no method 'split'"));
+    });
+  });
+});

data/spec/js/utilities.spec.js

@@ -4,9 +4,6 @@
 var TwitterCldr = require('../../lib/assets/javascripts/twitter_cldr/en.js');
 
 describe("Utilities", function() {
-  beforeEach(function() {
-  });
-
   describe("#is_even", function() {
     it("should return true if the given number is even", function() {
       for(var i = 0; i <= 1000; i += 2) {

data/twitter_cldr_js.gemspec

@@ -17,12 +17,13 @@ Gem::Specification.new do |s|
   s.add_dependency 'json'
   s.add_dependency 'twitter_cldr', '~> 2.4.0'
   s.add_dependency 'railties', '~> 3.1'
-  s.add_dependency 'rake', '~> 0.9.2.2'
-  s.add_dependency 'mustache', '~> 0.99.4'
-  s.add_dependency 'ruby_parser', '~> 2.3.1'
-  s.add_dependency 'therubyracer',  '~> 0.9.10'
-  s.add_dependency 'uglifier',      '~> 1.2.4'
-  s.add_dependency 'coffee-script', '~> 2.2.0'
+
+  s.add_development_dependency 'rake'
+  s.add_development_dependency 'mustache', '~> 0.99.4'
+  s.add_development_dependency 'ruby_parser', '~> 2.3.1'
+  s.add_development_dependency 'therubyracer',  '~> 0.11.4'
+  s.add_development_dependency 'uglifier',      '~> 1.2.4'
+  s.add_development_dependency 'coffee-script', '~> 2.2.0'
 
   s.require_path = 'lib'