i18n-js 2.1.2 → 3.0.0.rc1

data/spec/js/localization.spec.js

@@ -0,0 +1,41 @@
+var I18n = require("../../lib/i18n")
+  , Translations = require("./translations")
+;
+
+describe("Localization", function(){
+  var actual, expected;
+
+  beforeEach(function() {
+    I18n.reset();
+    I18n.translations = Translations();
+  });
+
+  it("localizes number", function(){
+    expect(I18n.l("number", 1234567)).toEqual("1,234,567.000");
+  });
+
+  it("localizes currency", function(){
+    expect(I18n.l("currency", 1234567)).toEqual("$1,234,567.00");
+  });
+
+  it("localizes date strings", function(){
+    I18n.locale = "pt-BR";
+
+    expect(I18n.l("date.formats.default", "2009-11-29")).toEqual("29/11/2009");
+    expect(I18n.l("date.formats.short", "2009-01-07")).toEqual("07 de Janeiro");
+    expect(I18n.l("date.formats.long", "2009-01-07")).toEqual("07 de Janeiro de 2009");
+  });
+
+  it("localizes time strings", function(){
+    I18n.locale = "pt-BR";
+
+    expect(I18n.l("time.formats.default", "2009-11-29 15:07:59")).toEqual("Domingo, 29 de Novembro de 2009, 15:07 h");
+    expect(I18n.l("time.formats.short", "2009-01-07 09:12:35")).toEqual("07/01, 09:12 h");
+    expect(I18n.l("time.formats.long", "2009-11-29 15:07:59")).toEqual("Domingo, 29 de Novembro de 2009, 15:07 h");
+  });
+
+  it("localizes percentage", function(){
+    I18n.locale = "pt-BR";
+    expect(I18n.l("percentage", 123.45)).toEqual("123,45%");
+  });
+});

data/spec/js/numbers.spec.js

@@ -0,0 +1,124 @@
+var I18n = require("../../lib/i18n")
+  , Translations = require("./translations")
+;
+
+describe("Numbers", function(){
+  var actual, expected;
+
+  beforeEach(function() {
+    I18n.reset();
+    I18n.translations = Translations();
+  });
+
+  it("formats number with default settings", function(){
+    expect(I18n.toNumber(1)).toEqual("1.000");
+    expect(I18n.toNumber(12)).toEqual("12.000");
+    expect(I18n.toNumber(123)).toEqual("123.000");
+    expect(I18n.toNumber(1234)).toEqual("1,234.000");
+    expect(I18n.toNumber(12345)).toEqual("12,345.000");
+    expect(I18n.toNumber(123456)).toEqual("123,456.000");
+    expect(I18n.toNumber(1234567)).toEqual("1,234,567.000");
+    expect(I18n.toNumber(12345678)).toEqual("12,345,678.000");
+    expect(I18n.toNumber(123456789)).toEqual("123,456,789.000");
+  });
+
+  it("formats negative numbers with default settings", function(){
+    expect(I18n.toNumber(-1)).toEqual("-1.000");
+    expect(I18n.toNumber(-12)).toEqual("-12.000");
+    expect(I18n.toNumber(-123)).toEqual("-123.000");
+    expect(I18n.toNumber(-1234)).toEqual("-1,234.000");
+    expect(I18n.toNumber(-12345)).toEqual("-12,345.000");
+    expect(I18n.toNumber(-123456)).toEqual("-123,456.000");
+    expect(I18n.toNumber(-1234567)).toEqual("-1,234,567.000");
+    expect(I18n.toNumber(-12345678)).toEqual("-12,345,678.000");
+    expect(I18n.toNumber(-123456789)).toEqual("-123,456,789.000");
+  });
+
+  it("formats number with partial translation and default options", function(){
+    I18n.translations.en.number = {
+      format: {
+        precision: 2
+      }
+    };
+
+    expect(I18n.toNumber(1234)).toEqual("1,234.00");
+  });
+
+  it("formats number with full translation and default options", function(){
+    I18n.translations.en.number = {
+      format: {
+        delimiter: ".",
+        separator: ",",
+        precision: 2
+      }
+    };
+
+    expect(I18n.toNumber(1234)).toEqual("1.234,00");
+  });
+
+  it("formats numbers with some custom options that should be merged with default options", function(){
+    expect(I18n.toNumber(1234.56, {precision: 0})).toEqual("1,235");
+    expect(I18n.toNumber(1234, {separator: '-'})).toEqual("1,234-000");
+    expect(I18n.toNumber(1234, {delimiter: '_'})).toEqual("1_234.000");
+  });
+
+  it("formats number considering options", function(){
+    options = {
+      precision: 2,
+      separator: ",",
+      delimiter: "."
+    };
+
+    expect(I18n.toNumber(1, options)).toEqual("1,00");
+    expect(I18n.toNumber(12, options)).toEqual("12,00");
+    expect(I18n.toNumber(123, options)).toEqual("123,00");
+    expect(I18n.toNumber(1234, options)).toEqual("1.234,00");
+    expect(I18n.toNumber(123456, options)).toEqual("123.456,00");
+    expect(I18n.toNumber(1234567, options)).toEqual("1.234.567,00");
+    expect(I18n.toNumber(12345678, options)).toEqual("12.345.678,00");
+  });
+
+  it("formats numbers with different precisions", function(){
+    options = {separator: ".", delimiter: ","};
+
+    options["precision"] = 2;
+    expect(I18n.toNumber(1.98, options)).toEqual("1.98");
+
+    options["precision"] = 3;
+    expect(I18n.toNumber(1.98, options)).toEqual("1.980");
+
+    options["precision"] = 2;
+    expect(I18n.toNumber(1.987, options)).toEqual("1.99");
+
+    options["precision"] = 1;
+    expect(I18n.toNumber(1.98, options)).toEqual("2.0");
+
+    options["precision"] = 0;
+    expect(I18n.toNumber(1.98, options)).toEqual("2");
+  });
+
+  it("returns number as human size", function(){
+    var kb = 1024;
+
+    expect(I18n.toHumanSize(1)).toEqual("1Byte");
+    expect(I18n.toHumanSize(100)).toEqual("100Bytes");
+
+    expect(I18n.toHumanSize(kb)).toEqual("1KB");
+    expect(I18n.toHumanSize(kb * 1.5)).toEqual("1.5KB");
+
+    expect(I18n.toHumanSize(kb * kb)).toEqual("1MB");
+    expect(I18n.toHumanSize(kb * kb * 1.5)).toEqual("1.5MB");
+
+    expect(I18n.toHumanSize(kb * kb * kb)).toEqual("1GB");
+    expect(I18n.toHumanSize(kb * kb * kb * 1.5)).toEqual("1.5GB");
+
+    expect(I18n.toHumanSize(kb * kb * kb * kb)).toEqual("1TB");
+    expect(I18n.toHumanSize(kb * kb * kb * kb * 1.5)).toEqual("1.5TB");
+
+    expect(I18n.toHumanSize(kb * kb * kb * kb * kb)).toEqual("1024TB");
+  });
+
+  it("returns number as human size using custom options", function(){
+    expect(I18n.toHumanSize(1024 * 1.6, {precision: 0})).toEqual("2KB");
+  });
+});

data/spec/js/placeholder.spec.js

@@ -0,0 +1,24 @@
+var I18n = require("../../lib/i18n");
+
+describe("Placeholder", function(){
+  beforeEach(function(){
+    I18n.reset();
+  });
+
+  it("matches {{name}}", function(){
+    expect("{{name}}").toMatch(I18n.placeholder);
+  });
+
+  it("matches %{name}", function(){
+    expect("%{name}").toMatch(I18n.placeholder);
+  });
+
+  it("returns placeholders", function(){
+    var translation = "I like %{javascript}. I also like %{ruby}"
+      , matches = translation.match(I18n.placeholder);
+    ;
+
+    expect(matches[0]).toEqual("%{javascript}");
+    expect(matches[1]).toEqual("%{ruby}");
+  });
+});

data/spec/js/pluralization.spec.js

@@ -0,0 +1,105 @@
+var I18n = require("../../lib/i18n")
+  , Translations = require("./translations")
+;
+
+describe("Pluralization", function(){
+  var actual, expected;
+
+  beforeEach(function(){
+    I18n.reset();
+    I18n.translations = Translations();
+  });
+
+  it("sets alias", function() {
+    expect(I18n.p).toEqual(I18n.pluralize);
+  });
+
+  it("pluralizes scope", function(){
+    expect(I18n.p(0, "inbox")).toEqual("You have no messages");
+    expect(I18n.p(1, "inbox")).toEqual("You have 1 message");
+    expect(I18n.p(5, "inbox")).toEqual("You have 5 messages");
+  });
+
+  it("pluralizes using the 'other' scope", function(){
+    I18n.translations["en"]["inbox"]["zero"] = null;
+    expect(I18n.p(0, "inbox")).toEqual("You have 0 messages");
+  });
+
+  it("pluralizes using the 'zero' scope", function(){
+    I18n.translations["en"]["inbox"]["zero"] = "No messages (zero)";
+
+    expect(I18n.p(0, "inbox")).toEqual("No messages (zero)");
+  });
+
+  it("pluralizes using negative values", function(){
+    expect(I18n.p(-1, "inbox")).toEqual("You have -1 message");
+    expect(I18n.p(-5, "inbox")).toEqual("You have -5 messages");
+  });
+
+  it("returns missing translation", function(){
+    expect(I18n.p(-1, "missing")).toEqual('[missing "en.missing" translation]');
+  });
+
+  it("pluralizes using multiple placeholders", function(){
+    actual = I18n.p(1, "unread", {unread: 5});
+    expect(actual).toEqual("You have 1 new message (5 unread)");
+
+    actual = I18n.p(10, "unread", {unread: 2});
+    expect(actual).toEqual("You have 10 new messages (2 unread)");
+
+    actual = I18n.p(0, "unread", {unread: 5});
+    expect(actual).toEqual("You have no new messages (5 unread)");
+  });
+
+  it("allows empty strings", function(){
+    I18n.translations["en"]["inbox"]["zero"] = "";
+
+    expect(I18n.p(0, "inbox")).toEqual("");
+  });
+
+  it("pluralizes using custom rules", function() {
+    I18n.locale = "custom";
+
+    I18n.pluralization["custom"] = function(count) {
+      if (count === 0) { return ["zero"]; }
+      if (count >= 1 && count <= 5) { return ["few", "other"]; }
+      return ["other"];
+    };
+
+    I18n.translations["custom"] = {
+      "things": {
+          "zero": "No things"
+        , "few": "A few things"
+        , "other": "%{count} things"
+      }
+    }
+
+    expect(I18n.p(0, "things")).toEqual("No things");
+    expect(I18n.p(4, "things")).toEqual("A few things");
+    expect(I18n.p(10, "things")).toEqual("10 things");
+  });
+
+  it("pluralizes default value", function(){
+    options = {defaultValue: {
+        zero: "No things here!"
+      , one: "There is {{count}} thing here!"
+      , other: "There are {{count}} things here!"
+    }};
+
+    expect(I18n.p(0, "things", options)).toEqual("No things here!");
+    expect(I18n.p(1, "things", options)).toEqual("There is 1 thing here!");
+    expect(I18n.p(5, "things", options)).toEqual("There are 5 things here!");
+  });
+
+  it("ignores pluralization when scope exists", function(){
+    options = {defaultValue: {
+        zero: "No things here!"
+      , one: "There is {{count}} thing here!"
+      , other: "There are {{count}} things here!"
+    }};
+
+    expect(I18n.p(0, "inbox", options)).toEqual("You have no messages");
+    expect(I18n.p(1, "inbox", options)).toEqual("You have 1 message");
+    expect(I18n.p(5, "inbox", options)).toEqual("You have 5 messages");
+  });
+});

data/spec/js/prepare_options.spec.js

@@ -0,0 +1,41 @@
+var I18n = require("../../lib/i18n");
+
+describe("Prepare options", function(){
+  beforeEach(function(){
+    I18n.reset();
+  });
+
+  it("merges two objects", function(){
+    var options = I18n.prepareOptions(
+      {name: "Mary Doe"},
+      {name: "John Doe", role: "user"}
+    );
+
+    expect(options.name).toEqual("Mary Doe");
+    expect(options.role).toEqual("user");
+  });
+
+  it("merges multiple objects", function(){
+    var options = I18n.prepareOptions(
+      {name: "Mary Doe"},
+      {name: "John Doe", role: "user"},
+      {age: 33},
+      {email: "mary@doe.com", url: "http://marydoe.com"},
+      {role: "admin", email: "john@doe.com"}
+    );
+
+    expect(options.name).toEqual("Mary Doe");
+    expect(options.role).toEqual("user");
+    expect(options.age).toEqual(33);
+    expect(options.email).toEqual("mary@doe.com");
+    expect(options.url).toEqual("http://marydoe.com");
+  });
+
+  it("returns an empty object when values are null", function(){
+    expect(I18n.prepareOptions(null, null)).toEqual({});
+  });
+
+  it("returns an empty object when values are undefined", function(){
+    expect(I18n.prepareOptions(undefined, undefined)).toEqual({});
+  });
+});

data/spec/js/specs.html

@@ -0,0 +1,46 @@
+<!DOCTYPE html>
+<html lang="en">
+    <head>
+        <meta charset="UTF-8">
+        <title>Jasmine Spec Runner</title>
+        <link rel="stylesheet" href="jasmine/jasmine.css" type="text/css">
+    </head>
+
+    <body>
+        <!-- load jasmine -->
+        <script type="text/javascript" src="jasmine/jasmine.js"></script>
+        <script type="text/javascript" src="jasmine/jasmine-html.js"></script>
+
+        <!-- load your javascript files -->
+        <script type="text/javascript" src="../../lib/i18n.js"></script>
+        <script type="text/javascript">
+          function require(path) {
+            if (path.match(/i18n/)) {
+              return I18n;
+            } else {
+              return Translations;
+            }
+          }
+        </script>
+
+        <!-- load your spec files -->
+        <script type="text/javascript" src="translations.js"></script>
+        <script type="text/javascript" src="currency.spec.js"></script>
+        <script type="text/javascript" src="current_locale.spec.js"></script>
+        <script type="text/javascript" src="dates.spec.js"></script>
+        <script type="text/javascript" src="defaults.spec.js"></script>
+        <script type="text/javascript" src="interpolation.spec.js"></script>
+        <script type="text/javascript" src="localization.spec.js"></script>
+        <script type="text/javascript" src="numbers.spec.js"></script>
+        <script type="text/javascript" src="placeholder.spec.js"></script>
+        <script type="text/javascript" src="pluralization.spec.js"></script>
+        <script type="text/javascript" src="prepare_options.spec.js"></script>
+        <script type="text/javascript" src="translate.spec.js"></script>
+
+        <!-- run specs -->
+        <script type="text/javascript">
+          jasmine.getEnv().addReporter(new jasmine.TrivialReporter());
+          jasmine.getEnv().execute();
+        </script>
+    </body>
+</html>

data/spec/js/translate.spec.js

@@ -0,0 +1,115 @@
+var I18n = require("../../lib/i18n")
+  , Translations = require("./translations")
+;
+
+describe("Translate", function(){
+  var actual, expected;
+
+  beforeEach(function(){
+    I18n.reset();
+    I18n.translations = Translations();
+  });
+
+  it("returns translation for single scope", function(){
+    expect(I18n.t("hello")).toEqual("Hello World!");
+  });
+
+  it("returns translation as object", function(){
+    expect(I18n.t("greetings")).toEqual(I18n.translations.en.greetings);
+  });
+
+  it("returns missing message translation for invalid scope", function(){
+    actual = I18n.t("invalid.scope");
+    expected = '[missing "en.invalid.scope" translation]';
+    expect(actual).toEqual(expected);
+  });
+
+  it("returns translation for single scope on a custom locale", function(){
+    I18n.locale = "pt-BR";
+    expect(I18n.t("hello")).toEqual("Olá Mundo!");
+  });
+
+  it("returns translation for multiple scopes", function(){
+    expect(I18n.t("greetings.stranger")).toEqual("Hello stranger!");
+  });
+
+  it("returns translation with default locale option", function(){
+    expect(I18n.t("hello", {locale: "en"})).toEqual("Hello World!");
+    expect(I18n.t("hello", {locale: "pt-BR"})).toEqual("Olá Mundo!");
+  });
+
+  it("fallbacks to the default locale when I18n.fallbackss is enabled", function(){
+    I18n.locale = "pt-BR";
+    I18n.fallbacks = true;
+    expect(I18n.t("greetings.stranger")).toEqual("Hello stranger!");
+  });
+
+  it("fallbacks to default locale when providing an unknown locale", function(){
+    I18n.locale = "fr";
+    I18n.fallbacks = true;
+    expect(I18n.t("greetings.stranger")).toEqual("Hello stranger!");
+  });
+
+  it("fallbacks to less specific locale", function(){
+    I18n.locale = "de-DE";
+    I18n.fallbacks = true;
+    expect(I18n.t("hello")).toEqual("Hallo Welt!");
+  });
+
+  it("fallbacks using custom rules (function)", function(){
+    I18n.locale = "no";
+    I18n.fallbacks = true;
+    I18n.locales["no"] = function() {
+      return ["nb"];
+    };
+
+    expect(I18n.t("hello")).toEqual("Hei Verden!");
+  });
+
+  it("fallbacks using custom rules (array)", function() {
+    I18n.locale = "no";
+    I18n.fallbacks = true;
+    I18n.locales["no"] = ["no", "nb"];
+
+    expect(I18n.t("hello")).toEqual("Hei Verden!");
+  });
+
+  it("fallbacks using custom rules (string)", function() {
+    I18n.locale = "no";
+    I18n.fallbacks = true;
+    I18n.locales["no"] = "nb";
+
+    expect(I18n.t("hello")).toEqual("Hei Verden!");
+  });
+
+  it("uses default value for simple translation", function(){
+    actual = I18n.t("warning", {defaultValue: "Warning!"});
+    expect(actual).toEqual("Warning!");
+  });
+
+  it("uses default value for unknown locale", function(){
+    I18n.locale = "fr";
+    actual = I18n.t("warning", {defaultValue: "Warning!"});
+    expect(actual).toEqual("Warning!");
+  });
+
+  it("uses default value with interpolation", function(){
+    actual = I18n.t(
+      "alert",
+      {defaultValue: "Attention! {{message}}", message: "You're out of quota!"}
+    );
+
+    expect(actual).toEqual("Attention! You're out of quota!");
+  });
+
+  it("ignores default value when scope exists", function(){
+    actual = I18n.t("hello", {defaultValue: "What's up?"});
+    expect(actual).toEqual("Hello World!");
+  });
+
+  it("returns translation for custom scope separator", function(){
+    I18n.defaultSeparator = "•";
+    actual = I18n.t("greetings•stranger");
+    expect(actual).toEqual("Hello stranger!");
+  });
+});