twitter_cldr_js 3.2.0 → 3.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f742c2e22d518081be5a938b080d64766cc4a125f55e75f4c8e75c4d2e9f7f14
-  data.tar.gz: 2168845da6ba9b3a7aee973176a70baa5585a7d58ed1c86b91a6f9b1a717c43e
+  metadata.gz: c7fa717f3763a3f4ca2593e5ff7104fea5f2cb56959bc89fc93f93219f34b82a
+  data.tar.gz: 2a1a5fe1a2f32f4eaf80f78b5aefe081b6fc85cce453940dfbe254a11d86becf
 SHA512:
-  metadata.gz: f85ecdbdc0b8ba32057c1f053636bfa11ff83f9db712a82ebf7da61971b0bc56847c36e5557348d221579c007d2adf923abf9956d8ba2356743d7bceaf403933
-  data.tar.gz: 4d8022ebbfca34498ae0d62d6d4efc25c6e8f3b928d0a3b92525b2674fb37a632638cef04496cbbc0a8f88957e9095f8d53fc0880587462038432d524a4b60bd
+  metadata.gz: 77e9dd6b9439d03d11c26de9027dc7080a5dcbd46519f58623931a864c2f09c11654ff8cc79855eb8e175b329613ea744aa24db235748fa03aff40f610b20040
+  data.tar.gz: 30a80da24b9d490da60530f0d0470264f766748d4fc2756235f2ee6edce5bf070831a5ed5c61b08b06bad732aca44f34b34499168fc1ab5a5d8f5f2a912a893f

data/Gemfile

@@ -3,7 +3,7 @@ source "https://rubygems.org"
 gemspec
 
 group :test do
-  gem 'rspec', '~> 2.11.0'
+  gem 'rspec', '~> 3.0'
   gem 'rr',    '~> 1.0.4'
 end
 

data/README.md

@@ -297,7 +297,7 @@ formatter.format(123, 'OrdinalRules', 'digits-ordinal')
 // '123rd'
 ```
 
-In comparision, here is what the Spanish formatting looks like
+In comparison, here is what the Spanish formatting looks like
 ```javascript
 // include the es data bundle for the Spanish RBNF Formatter
 var formatter = new TwitterCldr.RBNF()
@@ -397,7 +397,7 @@ TwitterCldr.TerritoriesContainment.contains('419', 'FR') // false
 
 ### Unicode Regular Expressions
 
-Unicode regular expressions are an implmentaion of regular expressions that support all Unicode characters in the [BMP](http://en.wikipedia.org/wiki/Plane_(Unicode)#Basic_Multilingual_Plane). They provide support for multi-character strings, Unicode character escapes, set operations (unions, intersections, and differences), and character sets.
+Unicode regular expressions are an implementaion of regular expressions that support all Unicode characters in the [BMP](http://en.wikipedia.org/wiki/Plane_(Unicode)#Basic_Multilingual_Plane). They provide support for multi-character strings, Unicode character escapes, set operations (unions, intersections, and differences), and character sets.
 
 #### Changes to Character Classes
 
@@ -429,7 +429,7 @@ regex3 = TwitterCldr.UnicodeRegex.compile("[[a-z]-[d-g]]+", "g");
 							//supports the JavaScript RegExp modifiers
 ```
 
-Once compiled, instances of `UnicodeRegex` behave just like normal javascript regexes and support the `match` method:
+Once compiled, instances of `UnicodeRegex` can be directly used to match against a string:
 
 ```javascript
 
@@ -438,6 +438,15 @@ regex2.match("ABCDfooABC");  // ["ABCD", "ABC"]
 regex3.match("dog"); // ["o"]
 ```
 
+Alternatively, you can convert a `UnicodeRegex` into a native JavaScript regex by calling its `to_regexp` method:
+
+```javascript
+
+regex3.to_regexp(); // /(?:[\u0061-\u0063]|[\u0068-\u007a])+/g
+regex3.to_regexp().test("a"); // true
+regex3.to_regexp().test("d"); // false
+```
+
 Protip: Try to avoid negation in character classes (eg. [^abc] and \P{Lu}) as it tends to negatively affect both performance when constructing regexes as well as matching.
 
 ### Text Segmentation

data/lib/assets/javascripts/twitter_cldr/core.js

@@ -16,10 +16,11 @@
 /*_lib/twitter_cldr_*/
 
 (function() {
-  var TwitterCldr, key, obj, root,
+  var TwitterCldr, get_with_data_isolation, key, obj, proxy_or_primitive, root, with_data_isolation,
     __hasProp = {}.hasOwnProperty,
     __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
-    __indexOf = [].indexOf || function(item) { for (var i = 0, l = this.length; i < l; i++) { if (i in this && this[i] === item) return i; } return -1; };
+    __indexOf = [].indexOf || function(item) { for (var i = 0, l = this.length; i < l; i++) { if (i in this && this[i] === item) return i; } return -1; },
+    __slice = [].slice;
 
   TwitterCldr = {};
 
@@ -3607,7 +3608,7 @@
     };
 
     NumberFormatter.prototype.format = function(number, options) {
-      var fraction, fraction_format, integer_format, intg, key, opts, prefix, result, sign, suffix, tokens, tokens_sample, truncated_number, val, _ref, _ref1;
+      var fraction, fraction_format, integer_format, intg, key, number_part, opts, prefix, result, rounded_num, sign, suffix, tokens, tokens_sample, truncated_number, val, _ref, _ref1;
       if (options == null) {
         options = {};
       }
@@ -3616,27 +3617,38 @@
         val = options[key];
         opts[key] = options[key] != null ? options[key] : opts[key];
       }
+      number = this.round_to(number, opts.precision || 0);
       tokens = this.get_tokens(number, opts);
       if (tokens != null) {
         if (!(tokens instanceof Array)) {
           tokens_sample = tokens[Object.keys(tokens)[0]];
           truncated_number = this.truncate_number(number, tokens_sample[1].length);
+          rounded_num = Number(this.parse_number(truncated_number, opts)[0]) * Number(this.get_key(number)) / (Math.pow(10, tokens_sample[1].length - 1));
+          if (!opts._stack_depth && this.get_key(rounded_num) !== this.get_key(number)) {
+            return this.format(rounded_num, Object.assign(opts, {
+              _stack_depth: 1
+            }));
+          }
           if (opts.precision === 0) {
             truncated_number = Math.floor(truncated_number);
           }
           tokens = tokens[TwitterCldr.PluralRules.rule_for(truncated_number)];
         }
         _ref = this.partition_tokens(tokens), prefix = _ref[0], suffix = _ref[1], integer_format = _ref[2], fraction_format = _ref[3];
-        number = this.truncate_number(number, integer_format.format.length);
-        _ref1 = this.parse_number(number, opts), intg = _ref1[0], fraction = _ref1[1];
+        number_part = this.truncate_number(number, integer_format.format.length);
+        _ref1 = this.parse_number(number_part, opts), intg = _ref1[0], fraction = _ref1[1];
         result = integer_format.apply(parseFloat(intg), opts);
         if (fraction) {
           result += fraction_format.apply(fraction, opts);
         }
-        sign = number < 0 && prefix !== "-" ? this.symbols().minus_sign || this.default_symbols.minus_sign : "";
+        sign = number_part < 0 && prefix !== "-" ? this.symbols().minus_sign || this.default_symbols.minus_sign : "";
         return "" + prefix + result + suffix;
       } else {
-        return number.toString();
+        if (!(this instanceof TwitterCldr.DecimalFormatter)) {
+          return new TwitterCldr.DecimalFormatter().format(number, opts);
+        } else {
+          return number.toString();
+        }
       }
     };
 
@@ -3679,7 +3691,7 @@
     };
 
     NumberFormatter.prototype.get_tokens = function() {
-      throw "get_tokens() not implemented - use a derived class like PercentFormatter.";
+      throw new Error("get_tokens() not implemented - use a derived class like PercentFormatter.");
     };
 
     return NumberFormatter;
@@ -3746,7 +3758,7 @@
         return result;
       } catch (_error) {
         error = _error;
-        return number;
+        return number.toString();
       }
     };
 
@@ -5447,6 +5459,292 @@
 
   })();
 
+  with_data_isolation = function(data) {
+    return function(fn) {
+      var original, result;
+      original = TwitterCldr.data;
+      TwitterCldr.data = data;
+      result = fn();
+      TwitterCldr.data = original;
+      return result;
+    };
+  };
+
+  get_with_data_isolation = function(data) {
+    return function(target, property_key, receiver) {
+      var isolate_data;
+      isolate_data = with_data_isolation(data);
+      return isolate_data(function() {
+        var fn, result;
+        result = Reflect.get(target, property_key, receiver);
+        if (typeof result === 'function') {
+          fn = result;
+          result = function() {
+            var args;
+            args = 1 <= arguments.length ? __slice.call(arguments, 0) : [];
+            return isolate_data(function() {
+              return Reflect.apply(fn, target, args);
+            });
+          };
+        }
+        return result;
+      });
+    };
+  };
+
+  proxy_or_primitive = function(value, handlers) {
+    if (value instanceof Object) {
+      return new Proxy(value, handlers);
+    } else {
+      return value;
+    }
+  };
+
+  TwitterCldr.clone = function(data) {
+    var get, isolate_data;
+    if (!data) {
+      throw new Error('Cannot create a clone with no data');
+    }
+    get = get_with_data_isolation(data);
+    isolate_data = with_data_isolation(data);
+    return proxy_or_primitive(root, {
+      get: function(target, property_key, receiver) {
+        switch (property_key) {
+          case 'set_data':
+            return function() {
+              throw new Error('Cannot set data on a TwitterCldr clone');
+            };
+          default:
+            return isolate_data(function() {
+              return proxy_or_primitive(Reflect.get(target, property_key, receiver), {
+                get: get,
+                apply: function() {
+                  var args;
+                  args = 1 <= arguments.length ? __slice.call(arguments, 0) : [];
+                  return isolate_data(function() {
+                    return Reflect.apply.apply(Reflect, args);
+                  });
+                },
+                construct: function() {
+                  var args;
+                  args = 1 <= arguments.length ? __slice.call(arguments, 0) : [];
+                  return isolate_data(function() {
+                    return proxy_or_primitive(Reflect.construct.apply(Reflect, args), {
+                      get: get
+                    });
+                  });
+                }
+              });
+            });
+        }
+      },
+      set: function() {
+        throw new Error('Cannot set properties on a TwitterCldr clone');
+      }
+    });
+  };
+
+  TwitterCldr.get_available_locales = function() {
+    return [
+      {
+        "locale": "af",
+        "file_name": "af"
+      }, {
+        "locale": "ar",
+        "file_name": "ar"
+      }, {
+        "locale": "be",
+        "file_name": "be"
+      }, {
+        "locale": "bg",
+        "file_name": "bg"
+      }, {
+        "locale": "bn",
+        "file_name": "bn"
+      }, {
+        "locale": "ca",
+        "file_name": "ca"
+      }, {
+        "locale": "cs",
+        "file_name": "cs"
+      }, {
+        "locale": "cy",
+        "file_name": "cy"
+      }, {
+        "locale": "da",
+        "file_name": "da"
+      }, {
+        "locale": "de",
+        "file_name": "de"
+      }, {
+        "locale": "de-CH",
+        "file_name": "de-CH"
+      }, {
+        "locale": "el",
+        "file_name": "el"
+      }, {
+        "locale": "en",
+        "file_name": "en"
+      }, {
+        "locale": "en-150",
+        "file_name": "en-150"
+      }, {
+        "locale": "en-AU",
+        "file_name": "en-AU"
+      }, {
+        "locale": "en-CA",
+        "file_name": "en-CA"
+      }, {
+        "locale": "en-GB",
+        "file_name": "en-GB"
+      }, {
+        "locale": "en-IE",
+        "file_name": "en-IE"
+      }, {
+        "locale": "en-SG",
+        "file_name": "en-SG"
+      }, {
+        "locale": "en-ZA",
+        "file_name": "en-ZA"
+      }, {
+        "locale": "es",
+        "file_name": "es"
+      }, {
+        "locale": "es-419",
+        "file_name": "es-419"
+      }, {
+        "locale": "es-CO",
+        "file_name": "es-CO"
+      }, {
+        "locale": "es-MX",
+        "file_name": "es-MX"
+      }, {
+        "locale": "es-US",
+        "file_name": "es-US"
+      }, {
+        "locale": "eu",
+        "file_name": "eu"
+      }, {
+        "locale": "fa",
+        "file_name": "fa"
+      }, {
+        "locale": "fi",
+        "file_name": "fi"
+      }, {
+        "locale": "fil",
+        "file_name": "fil"
+      }, {
+        "locale": "fr",
+        "file_name": "fr"
+      }, {
+        "locale": "fr-BE",
+        "file_name": "fr-BE"
+      }, {
+        "locale": "fr-CA",
+        "file_name": "fr-CA"
+      }, {
+        "locale": "fr-CH",
+        "file_name": "fr-CH"
+      }, {
+        "locale": "ga",
+        "file_name": "ga"
+      }, {
+        "locale": "gl",
+        "file_name": "gl"
+      }, {
+        "locale": "he",
+        "file_name": "he"
+      }, {
+        "locale": "hi",
+        "file_name": "hi"
+      }, {
+        "locale": "hr",
+        "file_name": "hr"
+      }, {
+        "locale": "hu",
+        "file_name": "hu"
+      }, {
+        "locale": "id",
+        "file_name": "id"
+      }, {
+        "locale": "is",
+        "file_name": "is"
+      }, {
+        "locale": "it",
+        "file_name": "it"
+      }, {
+        "locale": "it-CH",
+        "file_name": "it-CH"
+      }, {
+        "locale": "ja",
+        "file_name": "ja"
+      }, {
+        "locale": "ko",
+        "file_name": "ko"
+      }, {
+        "locale": "lv",
+        "file_name": "lv"
+      }, {
+        "locale": "ms",
+        "file_name": "msa"
+      }, {
+        "locale": "nb",
+        "file_name": "no"
+      }, {
+        "locale": "nl",
+        "file_name": "nl"
+      }, {
+        "locale": "pl",
+        "file_name": "pl"
+      }, {
+        "locale": "pt",
+        "file_name": "pt"
+      }, {
+        "locale": "ro",
+        "file_name": "ro"
+      }, {
+        "locale": "ru",
+        "file_name": "ru"
+      }, {
+        "locale": "sk",
+        "file_name": "sk"
+      }, {
+        "locale": "sq",
+        "file_name": "sq"
+      }, {
+        "locale": "sr",
+        "file_name": "sr"
+      }, {
+        "locale": "sv",
+        "file_name": "sv"
+      }, {
+        "locale": "ta",
+        "file_name": "ta"
+      }, {
+        "locale": "th",
+        "file_name": "th"
+      }, {
+        "locale": "tr",
+        "file_name": "tr"
+      }, {
+        "locale": "uk",
+        "file_name": "uk"
+      }, {
+        "locale": "ur",
+        "file_name": "ur"
+      }, {
+        "locale": "vi",
+        "file_name": "vi"
+      }, {
+        "locale": "zh",
+        "file_name": "zh-cn"
+      }, {
+        "locale": "zh-Hant",
+        "file_name": "zh-tw"
+      }
+    ];
+  };
+
   TwitterCldr.set_data = function(bundle) {
     TwitterCldr.data = bundle;
     return null;

data/lib/twitter_cldr/js/compiler.rb

@@ -89,6 +89,16 @@ module TwitterCldr
       def compile_implementation(options = {})
         bundle = TwitterCldr::Js::Renderers::Bundle.new
         bundle[:locale] = TwitterCldr::DEFAULT_LOCALE
+
+        available_locales = @locales.map do |locale|
+          {
+            locale: locale,
+            file_name: TwitterCldr.twitter_locale(locale),
+          }
+        end
+
+        bundle[:available_locales] = available_locales.sort_by { |x| x[:locale] }.to_json
+
         file = compile_bundle(bundle, @features, implementation_renderers, options)
 
         file.source
@@ -152,7 +162,8 @@ module TwitterCldr
           :plural                          => TwitterCldr::Js::Renderers::Implementation::Numbers::RBNF::PluralRenderer,
           :range                           => TwitterCldr::Js::Renderers::Implementation::Utils::RangeRenderer,
           :range_set                       => TwitterCldr::Js::Renderers::Implementation::Utils::RangeSetRenderer,
-          :code_points                     => TwitterCldr::Js::Renderers::Implementation::Utils::CodePointsRenderer
+          :code_points                     => TwitterCldr::Js::Renderers::Implementation::Utils::CodePointsRenderer,
+          :clone                           => TwitterCldr::Js::Renderers::Implementation::Clone::CloneRenderer,
         }
       end
 

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

@@ -23,6 +23,8 @@ TwitterCldr = {}
 {{> utilities}}
 {{{contents}}}
 
+TwitterCldr.get_available_locales = -> {{{available_locales}}}
+
 TwitterCldr.set_data = (bundle) ->
   TwitterCldr.data = bundle
   null

data/lib/twitter_cldr/js/mustache/implementation/clone/clone.coffee

@@ -0,0 +1,58 @@
+with_data_isolation = (data) -> (fn) ->
+  original = TwitterCldr.data
+  TwitterCldr.data = data
+  result = fn()
+  TwitterCldr.data = original
+  result
+
+get_with_data_isolation = (data) -> (target, property_key, receiver) ->
+  isolate_data = with_data_isolation(data)
+
+  isolate_data(->
+    result = Reflect.get(target, property_key, receiver)
+
+    if typeof result == 'function'
+      fn = result
+
+      result = (args...) -> isolate_data(-> Reflect.apply(fn, target, args))
+
+    result
+  )
+
+proxy_or_primitive = (value, handlers) ->
+  if value instanceof Object
+    new Proxy(value, handlers)
+  else
+    value
+
+TwitterCldr.clone = (data) ->
+  if !data
+    throw new Error('Cannot create a clone with no data')
+
+  get = get_with_data_isolation(data)
+  isolate_data = with_data_isolation(data)
+
+  proxy_or_primitive(
+    root,
+    get: (target, property_key, receiver) ->
+      switch property_key
+        when 'set_data'
+          return -> throw new Error('Cannot set data on a TwitterCldr clone')
+        else
+          isolate_data(
+            -> proxy_or_primitive(
+              Reflect.get(target, property_key, receiver), {
+                get,
+                apply: (args...) ->
+                  isolate_data(
+                    -> Reflect.apply(args...)
+                  )
+                construct: (args...) ->
+                  isolate_data(
+                    -> proxy_or_primitive(Reflect.construct(args...), { get })
+                  )
+              }
+            )
+          )
+    set: () -> throw new Error('Cannot set properties on a TwitterCldr clone')
+  )

data/lib/twitter_cldr/js/mustache/implementation/numbers/numbers.coffee

@@ -21,30 +21,47 @@ class TwitterCldr.NumberFormatter
     @constructor.data().symbols
 
   format: (number, options = {}) ->
-    opts = this.default_format_options_for(number)
+    opts = @default_format_options_for(number)
 
     for key, val of options
       opts[key] = if options[key]? then options[key] else opts[key]
 
-    tokens = this.get_tokens(number, opts)
+    number = @round_to(number, opts.precision || 0)
+
+    tokens = @get_tokens(number, opts)
 
     if tokens?
       if tokens not instanceof Array
         tokens_sample = tokens[Object.keys(tokens)[0]]
         truncated_number = @truncate_number(number, tokens_sample[1].length)
+
+        rounded_num = Number(@parse_number(truncated_number, opts)[0]) * Number(@get_key(number)) / (10 ** (tokens_sample[1].length - 1))
+
+        # Checking _stack_depth should be a redundant condition, as
+        # @get_key(rounded_num) should always equal @get_key(number) the second
+        # time around. We only check it to prevent infinite loops in case of
+        # bugs
+        if !opts._stack_depth && @get_key(rounded_num) != @get_key(number)
+          return @format(rounded_num, Object.assign(opts, { _stack_depth: 1 }))
+
         truncated_number = Math.floor(truncated_number) if opts.precision == 0
         tokens = tokens[TwitterCldr.PluralRules.rule_for(truncated_number)]
 
-      [prefix, suffix, integer_format, fraction_format] = this.partition_tokens(tokens)
-      number = this.truncate_number(number, integer_format.format.length)
-      [intg, fraction] = this.parse_number(number, opts)
+      [prefix, suffix, integer_format, fraction_format] = @partition_tokens(tokens)
+      number_part = @truncate_number(number, integer_format.format.length)
+      [intg, fraction] = @parse_number(number_part, opts)
       result = integer_format.apply(parseFloat(intg), opts)
       result += fraction_format.apply(fraction, opts) if fraction
-      sign = if number < 0 && prefix != "-" then @symbols().minus_sign || @default_symbols.minus_sign else ""
+      sign = if number_part < 0 && prefix != "-" then @symbols().minus_sign || @default_symbols.minus_sign else ""
       "#{prefix}#{result}#{suffix}"
     else
-      # there's no specific formatting pattern for this number in current locale
-      number.toString()
+      unless @ instanceof TwitterCldr.DecimalFormatter
+        # No specific formatting pattern for this number in current locale, so
+        # we fall back to DecimalFormatter
+        new TwitterCldr.DecimalFormatter().format(number, opts)
+      else
+        # Use default toString if current instance is already a DecimalFormatter
+        number.toString()
 
   truncate_number: (number, decimal_digits) ->
     number  # noop for base class
@@ -75,7 +92,7 @@ class TwitterCldr.NumberFormatter
     Math.round(number * factor) / factor
 
   get_tokens: ->
-    throw "get_tokens() not implemented - use a derived class like PercentFormatter."
+    throw new Error("get_tokens() not implemented - use a derived class like PercentFormatter.")
 
 class TwitterCldr.PercentFormatter extends TwitterCldr.NumberFormatter
   constructor: (options = {}) ->
@@ -106,7 +123,7 @@ class TwitterCldr.DecimalFormatter extends TwitterCldr.NumberFormatter
           result = transliterator.transliterate(result)
       result
     catch error
-      number
+      number.toString()
 
   default_format_options_for: (number) ->
     precision: this.precision_from(number)

data/lib/twitter_cldr/js/renderers/implementation/clone.rb

@@ -0,0 +1,20 @@
+# encoding: UTF-8
+
+# Copyright 2012 Twitter, Inc
+# http://www.apache.org/licenses/LICENSE-2.0
+
+module TwitterCldr
+  module Js
+    module Renderers
+      module Implementation
+        module Clone
+
+          class CloneRenderer < TwitterCldr::Js::Renderers::Base
+            set_template "mustache/implementation/clone/clone.coffee"
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/twitter_cldr/js/renderers.rb

@@ -19,6 +19,7 @@ module TwitterCldr
         autoload :Numbers,                                'twitter_cldr/js/renderers/implementation/numbers'
         autoload :Parsers,                                'twitter_cldr/js/renderers/implementation/parsers'
         autoload :Tokenizers,                             'twitter_cldr/js/renderers/implementation/tokenizers'
+        autoload :Clone,                                  'twitter_cldr/js/renderers/implementation/clone'
 
       module Shared
           autoload :BidiRenderer,                         'twitter_cldr/js/renderers/implementation/shared/bidi_renderer'

data/lib/twitter_cldr/js/version.rb

@@ -5,6 +5,6 @@
 
 module TwitterCldr
   module Js
-    VERSION = "3.2.0"
+    VERSION = "3.3.0"
   end
 end

data/spec/js/clone/clone.spec.js

@@ -0,0 +1,234 @@
+const locales = "en,ar,ko,ru,hi".split(",");
+const date = new Date(2000, 1, 1);
+
+// Updated version of
+// https://github.com/twitter/twitter-cldr-npm/blob/master/twitter_cldr.js
+// that clones by default
+const load = function (locale, options) {
+  var defaultOptions = { clone: true };
+  options = options || {};
+
+  for (var k in defaultOptions) {
+    if (!(k in options)) {
+      options[k] = defaultOptions[k];
+    }
+  }
+
+  var TwitterCldr = require("../../../lib/assets/javascripts/twitter_cldr/core");
+  var data = require("../../../lib/assets/javascripts/twitter_cldr/" + locale);
+
+  if (options.clone) {
+    return TwitterCldr.clone(data);
+  } else {
+    TwitterCldr.set_data(data);
+    return TwitterCldr;
+  }
+};
+
+const checkDataIsolation = ({ class: klass, ctorParams, methods, staticMethods, loadOptions }) => {
+  methods = methods || {}
+  staticMethods = staticMethods || {}
+  ctorParams = ctorParams || []
+
+  describe(klass, () => {
+    const allMethods = [
+      ...(Object.entries(methods)).map(x => [false, ...x]),
+      ...(Object.entries(staticMethods)).map(x => [true, ...x]),
+    ]
+
+    for (let [static, name, { params, compare }] of allMethods) {
+      params = params || []
+      compare = compare || ((x) => x)
+
+      describe(`${static ? "." : "#"}${name}`, () => {
+        const twitterCldrs = locales.map((locale) => {
+          const params = [locale, loadOptions].filter((x) => x != null);
+          const TwitterCldr = load(...params);
+
+          return { locale, TwitterCldr };
+        });
+
+        const formatters = twitterCldrs.map(({ locale, TwitterCldr }) => {
+          const formatter = static ? TwitterCldr[klass] : new TwitterCldr[klass](...ctorParams)
+
+          return { locale, formatter };
+        });
+
+        const formatFns = formatters.map(({ locale, formatter }) => ({
+          locale,
+          format: formatter[name].bind(formatter),
+        }));
+
+        const results = formatFns.map(({ locale, format }) => ({
+          locale,
+          result: compare(format(...params)),
+        }));
+
+        it(`sanity check - result for same locale is equal`, () => {
+          const { formatter } = formatters[0];
+          const format = formatter[name].bind(formatter);
+
+          expect(compare(format(...params))).toBe(compare(format(...params)));
+        });
+
+        for (const [idx, { locale, result }] of results.entries()) {
+          const prevs = results.slice(0, idx);
+
+          if (!prevs.length) continue;
+
+          for (const prev of prevs) {
+            it(`result for "${locale}" differs from result for "${prev.locale}"`, () => {
+              expect(result).not.toBe(prev.result);
+            });
+          }
+        }
+      });
+    }
+  });
+};
+
+const tests = [
+  {
+    class: "DateTimeFormatter",
+    methods: {
+      format: { params: [date, { type: "full" }] },
+      weekday_local_stand_alone: { params: [date, "cc", 2] },
+    },
+  },
+  {
+    class: "Languages",
+    staticMethods: {
+      from_code: { params: ["en"] },
+      all: { params: [], compare: (x) => x.ja },
+    },
+  },
+  {
+    class: "RBNF",
+    methods: {
+      format: { params: [1, "SpelloutRules", "spellout-numbering"] },
+    },
+  }
+];
+
+describe("data isolation", () => {
+  for (const loadOptions of [
+    undefined, // no options param supplied
+    {}, // empty options - defaults to clone=true
+    { clone: true }, // explicitly specify clone=true
+  ]) {
+    tests.map((x) => ({ ...x, loadOptions })).forEach(checkDataIsolation);
+  }
+});
+
+describe("clone behavior", () => {
+  const TwitterCldr = require("../../../lib/assets/javascripts/twitter_cldr/core");
+  const en = require("../../../lib/assets/javascripts/twitter_cldr/en");
+  const ja = require("../../../lib/assets/javascripts/twitter_cldr/ja");
+
+  beforeEach(() => {
+    TwitterCldr.set_data(undefined);
+  })
+
+  afterEach(() => {
+    TwitterCldr.set_data(undefined);
+  });
+
+  const locale = (clone) => clone.get_data().Settings.locale;
+
+  it("can be cloned from base that has no data", () => {
+    const clone = TwitterCldr.clone(en);
+
+    expect(locale(clone)).toBe("en");
+    expect(TwitterCldr.is_data_set()).toBe(false);
+    expect(clone.is_data_set()).toBe(true);
+  });
+
+  it("returns undefined for properties not present on `root`", () => {
+    TwitterCldr.set_data(en);
+    const clone = TwitterCldr.clone(en);
+
+    expect(TwitterCldr.data).toBe(undefined);
+    expect(clone.data).toBe(undefined);
+  });
+
+  it("doesn't affect data of the base TwitterCldr", () => {
+    TwitterCldr.set_data(ja);
+    TwitterCldr.clone(en);
+
+    expect(locale(TwitterCldr)).toBe("ja");
+  });
+
+
+  it("isn't affected by data of the base TwitterCldr", () => {
+    const clone = TwitterCldr.clone(en);
+    TwitterCldr.set_data(ja);
+
+    expect(locale(clone)).toBe("en");
+  });
+
+  it("can be cloned indefinitely", () => {
+    const cloneEn1 = TwitterCldr.clone(en);
+    const cloneEn2 = cloneEn1.clone(en);
+    const cloneJa = cloneEn2.clone(ja);
+
+    expect(locale(cloneEn1)).toBe("en");
+    expect(locale(cloneEn2)).toBe(locale(cloneEn1));
+    expect(locale(cloneJa)).toBe("ja");
+  });
+
+  it("throws if attempting to create a clone with no data", () => {
+    expect(() => TwitterCldr.clone()).toThrow();
+    expect(() => TwitterCldr.clone(undefined)).toThrow();
+    expect(() => TwitterCldr.clone(null)).toThrow();
+
+    expect(() => TwitterCldr.clone({})).not.toThrow();
+  });
+
+  describe("cloned version throws if attempting to set data", () => {
+    const clone = TwitterCldr.clone(en);
+
+    it("using `set_data`", () => {
+      expect(() => clone.set_data({})).toThrow();
+    });
+
+    it("using `data = `", () => {
+      expect(() => clone.data = {}).toThrow();
+    });
+  });
+});
+
+describe("load(..., false)", () => {
+  describe("continues to use global state", () => {
+    const results = locales.map((locale) => {
+      const TwitterCldr = load(locale, { clone: false });
+      return new TwitterCldr.DateTimeFormatter();
+    }).map((formatter) => formatter.format(date, { type: "full" }));
+
+    describe("DateTimeFormatter", () => {
+      it("#format", () => {
+        expect(new Set(results).size).toEqual(1);
+      });
+    });
+  });
+
+  describe("works in environments without `Proxy` support", () => {
+    const originalProxy = globalThis.Proxy;
+
+    beforeEach(() => {
+      globalThis.Proxy = undefined;
+    });
+
+    afterEach(() => {
+      globalThis.Proxy = originalProxy;
+    });
+
+    describe("DateTimeFormatter", () => {
+      it("#weekday_local_stand_alone", () => {
+        const TwitterCldr = load("en", { clone: false });
+        const formatter = new TwitterCldr.DateTimeFormatter();
+
+        expect(formatter.weekday_local_stand_alone(date, "cc", 2)).toEqual("Tue");
+      });
+    });
+  });
+});

data/spec/js/numbers/long_short_decimal.spec.js

@@ -0,0 +1,77 @@
+const TwitterCldr = require("../../../lib/assets/javascripts/twitter_cldr/core.js");
+
+const testData = {
+  Long: {
+    "en": [
+      // edge cases
+      { raw: 999_499, precisions: ["999 thousand", "999.5 thousand"] },
+      { raw: 999_500, precisions: ["1 million", "999.5 thousand"] },
+      { raw: 1_000_000, precisions: ["1 million", "1.0 million"] },
+
+      // fractional
+      { raw: 999.49, precisions: ["999", "999.5"], default: "999.49" },
+      { raw: 999.5, precisions: ["1 thousand", "999.5"], default: "999.5" },
+
+      // negative
+      { raw: -1_000_000, precisions: ["-1,000,000"] },
+      { raw: -999_500, precisions: ["-999,500"] },
+    ],
+    "zh-cn": [
+      // edge cases
+      { raw: 9499, precisions: ["9千", "9.5千"] },
+      { raw: 9500, precisions: ["1万", "9.5千"] },
+      { raw: 10_000, precisions: ["1万", "1.0万"] },
+    ],
+    "es": [
+      // pluralization
+      { raw: 1e3, precisions: ["1 mil", "1,0 mil"] },
+      { raw: 2e3, precisions: ["2 mil", "2,0 mil"] },
+      { raw: 1e6, precisions: ["1 millón", "1,0 millón"] },
+      { raw: 2e6, precisions: ["2 millones", "2,0 millones"] },
+      { raw: 1e9, precisions: ["1 mil millones", "1,0 mil millones"] },
+
+      // fractional
+      { raw: 999.49, precisions: ["999", "999,5"], default: "999,49" },
+      { raw: 999.5, precisions: ["1 mil", "999,5"], default: "999,5" },
+
+      // negative
+      { raw: -1_000_000, precisions: ["-1.000.000"] },
+      { raw: -999_500, precisions: ["-999.500"] },
+    ],
+  },
+  Short: {
+    "en": [
+      // edge cases
+      { raw: 999_499, precisions: ["999K", "999.5K"] },
+      { raw: 999_500, precisions: ["1M", "999.5K"] },
+      { raw: 1_000_000, precisions: ["1M", "1.0M"] },
+    ],
+  },
+};
+
+for (const [kind, locales] of Object.entries(testData)) {
+  for (const [localeFileName, tests] of Object.entries(locales)) {
+    describe(`${kind}DecimalFormatter (${localeFileName})`, () => {
+      let formatter;
+
+      beforeEach(() => {
+        TwitterCldr.set_data(require(`../../../lib/assets/javascripts/twitter_cldr/${localeFileName}`));
+        formatter = new TwitterCldr[`${kind}DecimalFormatter`]();
+      });
+
+      describe("#format", () => {
+        for (const { raw, precisions, default: _default } of tests) {
+          it(`formats ${raw} with no options supplied`, () => {
+            expect(formatter.format(raw)).toEqual(_default ?? precisions[0]);
+          });
+
+          for (const [precision, expected] of precisions.entries()) {
+            it(`formats ${raw} to precision ${precision}`, () => {
+              expect(formatter.format(raw, { precision })).toEqual(expected);
+            });
+          }
+        }
+      });
+    });
+  }
+}

data/twitter_cldr_js.gemspec

@@ -14,12 +14,11 @@ Gem::Specification.new do |s|
   s.summary  = "Text formatting using data from Unicode's Common Locale Data Repository (CLDR)."
 
   s.add_dependency 'json'
-  s.add_dependency 'railties', '>= 3.0', '< 5.0'
+  s.add_dependency 'railties', '>= 3.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.12.0'
   s.add_development_dependency 'uglifier',                '~> 1.2.4'
   s.add_development_dependency 'coffee-script',           '~> 2.2.0'
   s.add_development_dependency 'coffee-script-source',    '~> 1.8.0'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: twitter_cldr_js
 version: !ruby/object:Gem::Version
-  version: 3.2.0
+  version: 3.3.0
 platform: ruby
 authors:
 - Cameron Dutro
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-08-26 00:00:00.000000000 Z
+date: 2023-03-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json
@@ -31,9 +31,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '3.0'
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: '5.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -41,9 +38,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '3.0'
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: '5.0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -86,20 +80,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 2.3.1
-- !ruby/object:Gem::Dependency
-  name: therubyracer
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 0.12.0
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 0.12.0
 - !ruby/object:Gem::Dependency
   name: uglifier
   requirement: !ruby/object:Gem::Requirement
@@ -257,6 +237,7 @@ files:
 - lib/twitter_cldr/js/mustache/implementation/calendars/additional_date_format_selector.coffee
 - lib/twitter_cldr/js/mustache/implementation/calendars/datetime.coffee
 - lib/twitter_cldr/js/mustache/implementation/calendars/timespan.coffee
+- lib/twitter_cldr/js/mustache/implementation/clone/clone.coffee
 - lib/twitter_cldr/js/mustache/implementation/numbers/numbers.coffee
 - lib/twitter_cldr/js/mustache/implementation/numbers/rbnf/formatters.coffee
 - lib/twitter_cldr/js/mustache/implementation/numbers/rbnf/number_data_reader.coffee
@@ -327,6 +308,7 @@ files:
 - lib/twitter_cldr/js/renderers/data/shared/list_renderer.rb
 - lib/twitter_cldr/js/renderers/data_bundle.rb
 - lib/twitter_cldr/js/renderers/implementation/calendars.rb
+- lib/twitter_cldr/js/renderers/implementation/clone.rb
 - lib/twitter_cldr/js/renderers/implementation/numbers.rb
 - lib/twitter_cldr/js/renderers/implementation/parsers.rb
 - lib/twitter_cldr/js/renderers/implementation/plurals.rb
@@ -352,6 +334,7 @@ files:
 - spec/js/calendars/datetime.spec.js
 - spec/js/calendars/timespan.ru.spec.js
 - spec/js/calendars/timespan.spec.js
+- spec/js/clone/clone.spec.js
 - spec/js/numbers/abbreviated/abbreviated_number.spec.js
 - spec/js/numbers/abbreviated/long_decimal.ko.spec.js
 - spec/js/numbers/abbreviated/long_decimal.ru.spec.js
@@ -364,6 +347,7 @@ files:
 - spec/js/numbers/decimal.spec.js
 - spec/js/numbers/helpers/fraction.spec.js
 - spec/js/numbers/helpers/integer.spec.js
+- spec/js/numbers/long_short_decimal.spec.js
 - spec/js/numbers/number.spec.js
 - spec/js/numbers/percent.spec.js
 - spec/js/numbers/rbnf.spec.js
@@ -416,7 +400,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.4
+rubygems_version: 3.1.6
 signing_key: 
 specification_version: 4
 summary: Text formatting using data from Unicode's Common Locale Data Repository (CLDR).