i18n-js-pika 3.0.0.rc6

data/spec/js/localization.spec.js

@@ -0,0 +1,41 @@
+var I18n = require("../../app/assets/javascripts/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,142 @@
+var I18n = require("../../app/assets/javascripts/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");
+  });
+
+  it("formats numbers with strip insignificant zero", function() {
+    options = {separator: ".", delimiter: ",", strip_insignificant_zeros: true};
+
+    options["precision"] = 2;
+    expect(I18n.toNumber(1.0, options)).toEqual("1");
+
+    options["precision"] = 3;
+    expect(I18n.toNumber(1.98, options)).toEqual("1.98");
+
+    options["precision"] = 4;
+    expect(I18n.toNumber(1.987, options)).toEqual("1.987");
+  });
+
+  it("keeps significant zeros [issue#103]", function() {
+    actual = I18n.toNumber(30, {strip_insignificant_zeros: true, precision: 0});
+    expect(actual).toEqual("30");
+  });
+});

data/spec/js/placeholder.spec.js

@@ -0,0 +1,24 @@
+var I18n = require("../../app/assets/javascripts/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("../../app/assets/javascripts/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("../../app/assets/javascripts/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="../../app/assets/javascripts/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,120 @@
+var I18n = require("../../app/assets/javascripts/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!");
+  });
+
+  it("returns boolean values", function() {
+    expect(I18n.t("booleans.yes")).toEqual(true);
+    expect(I18n.t("booleans.no")).toEqual(false);
+  });
+});

data/spec/js/translations.js

@@ -0,0 +1,120 @@
+;(function(){
+  var generator = function() {
+    var Translations = {};
+
+    Translations.en = {
+        hello: "Hello World!"
+
+      , booleans: {
+          yes: true,
+          no: false
+        }
+
+      , greetings: {
+            stranger: "Hello stranger!"
+          , name: "Hello {{name}}!"
+        }
+
+      , profile: {
+          details: "{{name}} is {{age}}-years old"
+        }
+
+      , inbox: {
+            one: "You have {{count}} message"
+          , other: "You have {{count}} messages"
+          , zero: "You have no messages"
+        }
+
+      , unread: {
+            one: "You have 1 new message ({{unread}} unread)"
+          , other: "You have {{count}} new messages ({{unread}} unread)"
+          , zero: "You have no new messages ({{unread}} unread)"
+        }
+
+      , number: {
+          human: {
+            storage_units: {
+                units: {
+                  "byte": {
+                      one: "Byte"
+                    , other: "Bytes"
+                  }
+                , "kb": "KB"
+                , "mb": "MB"
+                , "gb": "GB"
+                , "tb": "TB"
+              }
+            }
+          }
+        }
+    };
+
+    Translations["en-US"] = {
+      date: {
+          formats: {
+              "default": "%d/%m/%Y"
+            , "short": "%d de %B"
+            , "long": "%d de %B de %Y"
+          }
+
+        , day_names: ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"]
+        , abbr_day_names: ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"]
+        , month_names: [null, "January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"]
+        , abbr_month_names: [null, "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sept", "Oct", "Nov", "Dec"]
+        , meridian: ["am", "pm"]
+      }
+    };
+
+    Translations["pt-BR"] = {
+        hello: "Olá Mundo!"
+
+      , number: {
+          percentage: {
+            format: {
+                delimiter: ""
+              , separator: ","
+              , precision: 2
+            }
+          }
+        }
+
+      , date: {
+          formats: {
+              "default": "%d/%m/%Y"
+            , "short": "%d de %B"
+            , "long": "%d de %B de %Y"
+          }
+          , day_names: ["Domingo", "Segunda", "Terça", "Quarta", "Quinta", "Sexta", "Sábado"]
+          , abbr_day_names: ["Dom", "Seg", "Ter", "Qua", "Qui", "Sex", "Sáb"]
+          , month_names: [null, "Janeiro", "Fevereiro", "Março", "Abril", "Maio", "Junho", "Julho", "Agosto", "Setembro", "Outubro", "Novembro", "Dezembro"]
+          , abbr_month_names: [null, "Jan", "Fev", "Mar", "Abr", "Mai", "Jun", "Jul", "Ago", "Set", "Out", "Nov", "Dez"]
+        }
+
+      , time: {
+            formats: {
+                "default": "%A, %d de %B de %Y, %H:%M h"
+              , "short": "%d/%m, %H:%M h"
+              , "long": "%A, %d de %B de %Y, %H:%M h"
+            }
+          , am: "AM"
+          , pm: "PM"
+        }
+    };
+
+    Translations["de"] = {
+      hello: "Hallo Welt!"
+    };
+
+    Translations["nb"] = {
+      hello: "Hei Verden!"
+    };
+
+    return Translations;
+  };
+
+  if (typeof(exports) === "undefined") {
+    window.Translations = generator;
+  } else {
+    module.exports = generator;
+  }
+})();

data/spec/spec_helper.rb

@@ -0,0 +1,41 @@
+require "i18n"
+require "json"
+
+require "active_support/all"
+require "i18n/js"
+
+module Helpers
+  # Set the configuration as the current one
+  def set_config(path)
+    config = HashWithIndifferentAccess.new(YAML.load_file(File.dirname(__FILE__) + "/fixtures/#{path}"))
+    I18n::JS.stub(:config? => true, :config => config)
+  end
+
+  # Shortcut to I18n::JS.translations
+  def translations
+    I18n::JS.translations
+  end
+
+  def file_should_exist(name)
+    file_path = File.join(I18n::JS.export_dir, name)
+    File.should be_file(file_path)
+  end
+
+  def temp_path(file_name = "")
+    File.expand_path("../../tmp/i18n-js/#{file_name}", __FILE__)
+  end
+end
+
+RSpec.configure do |config|
+  config.before do
+    I18n.load_path = [File.dirname(__FILE__) + "/fixtures/locales.yml"]
+    FileUtils.rm_rf(temp_path)
+  end
+
+  config.after do
+    FileUtils.rm_rf(temp_path)
+  end
+
+  config.include Helpers
+end
+