i18n-js 0.1.0

data/lib/i18n-js/version.rb

@@ -0,0 +1,10 @@
+module SimplesIdeias
+  module I18n
+    module Version
+      MAJOR = 0
+      MINOR = 1
+      PATCH = 0
+      STRING = "#{MAJOR}.#{MINOR}.#{PATCH}"
+    end
+  end
+end

data/lib/tasks/i18n-js_tasks.rake

@@ -0,0 +1,16 @@
+namespace :i18n do
+  desc "Copy i18n.js and configuration file"
+  task :setup => :environment do
+    SimplesIdeias::I18n.setup!
+  end
+
+  desc "Export the messages files"
+  task :export => :environment do
+    SimplesIdeias::I18n.export!
+  end
+
+  desc "Update the JavaScript library"
+  task :update => :environment do
+    SimplesIdeias::I18n.update!
+  end
+end

data/source/i18n-js.yml

@@ -0,0 +1,4 @@
+# Find more details about this configuration file at http://github.com/fnando/i18n-js
+translations:
+  - file: "public/javascripts/translations.js"
+    only: "*"

data/source/i18n.js

@@ -0,0 +1,341 @@
+// Instantiate the object
+var I18n = I18n || {};
+
+// Set default locale to english
+I18n.defaultLocale = "en";
+
+// Set current locale to null
+I18n.locale = null;
+
+// Set the placeholder format. Accepts `{{placeholder}}` and `%{placeholder}`.
+I18n.PLACEHOLDER = /(?:\{\{|%\{)(.*?)(?:\}\}?)/gm;
+
+I18n.lookup = function(scope, options) {
+	var translations = this.prepareOptions(I18n.translations);
+	var messages = translations[I18n.currentLocale()];
+	options = this.prepareOptions(options);
+
+	if (!messages) {
+		return;
+	}
+
+	if (typeof(scope) == "object") {
+		scope = scope.join(".");
+	}
+
+	if (options.scope) {
+		scope = options.scope.toString() + "." + scope;
+	}
+
+	scope = scope.split(".");
+
+	while (scope.length > 0) {
+		var currentScope = scope.shift();
+		messages = messages[currentScope];
+
+		if (!messages) {
+			break;
+		}
+	}
+
+	if (!messages && options.defaultValue != null && options.defaultValue != undefined) {
+		messages = options.defaultValue;
+	}
+
+	return messages;
+};
+
+// Merge serveral hash options, checking if value is set before
+// overwriting any value. The precedence is from left to right.
+//
+//	 I18n.prepareOptions({name: "John Doe"}, {name: "Mary Doe", role: "user"});
+//	 #=> {name: "John Doe", role: "user"}
+//
+I18n.prepareOptions = function() {
+	var options = {};
+	var opts;
+	var count = arguments.length;
+
+	for (var i = 0; i < count; i++) {
+		opts = arguments[i];
+
+		if (!opts) {
+			continue;
+		}
+
+		for (var key in opts) {
+			if (options[key] == undefined || options[key] == null) {
+				options[key] = opts[key];
+			}
+		}
+	}
+
+	return options;
+};
+
+I18n.interpolate = function(message, options) {
+	options = this.prepareOptions(options);
+	var matches = message.match(this.PLACEHOLDER);
+
+	if (!matches) {
+		return message;
+	}
+
+	var placeholder, value, name;
+
+	for (var i = 0; placeholder = matches[i]; i++) {
+		console.debug(placeholder)
+		name = placeholder.replace(this.PLACEHOLDER, "$1");
+		console.debug(name)
+
+		value = options[name];
+
+		if (options[name] == null || options[name] == undefined) {
+			value = "[missing " + placeholder + " value]";
+		}
+
+		regex = new RegExp(placeholder.replace(/\{/gm, "\\{").replace(/\}/gm, "\\}"));
+		message = message.replace(regex, value);
+	}
+
+	return message;
+};
+
+I18n.translate = function(scope, options) {
+	options = this.prepareOptions(options);
+	var translation = this.lookup(scope, options);
+
+	try {
+		if (typeof(translation) == "object") {
+			if (typeof(options.count) == "number") {
+				return this.pluralize(options.count, scope, options);
+			} else {
+				return translation;
+			}
+		} else {
+			return this.interpolate(translation, options);
+		}
+	} catch(err) {
+		return this.missingTranslation(scope);
+	}
+};
+
+I18n.localize = function(scope, value) {
+	switch (scope) {
+		case "currency":
+			return this.toCurrency(value);
+		case "number":
+			scope = this.lookup("number.format");
+			return this.toNumber(value, scope);
+		case "percentage":
+			return this.toPercentage(value);
+		default:
+			if (scope.match(/^(date|time)/)) {
+				return this.toTime(scope, value);
+			} else {
+				return value.toString();
+			}
+	}
+};
+
+I18n.parseDate = function(d) {
+	var matches, date;
+
+	if (matches = d.toString().match(/(\d{4})-(\d{2})-(\d{2})(?:[ |T](\d{2}):(\d{2}):(\d{2}))?(Z)?/)) {
+		// date/time strings: yyyy-mm-dd hh:mm:ss or yyyy-mm-dd or yyyy-mm-ddThh:mm:ssZ
+		for (var i = 1; i <= 6; i++) {
+			matches[i] = parseInt(matches[i], 10) || 0;
+		}
+
+		// month starts on 0
+		matches[2] -= 1;
+
+		if (matches[7]) {
+			date = new Date(Date.UTC(matches[1], matches[2], matches[3], matches[4], matches[5], matches[6]));
+		} else {
+			date = new Date(matches[1], matches[2], matches[3], matches[4], matches[5], matches[6]);
+		}
+	} else if (typeof(d) == "number") {
+		// UNIX timestamp
+		date = new Date();
+		date.setTime(d);
+	} else {
+		// an arbitrary javascript string
+		date = new Date();
+		date.setTime(Date.parse(d));
+	}
+
+	return date;
+};
+
+I18n.toTime = function(scope, d) {
+	var date = this.parseDate(d);
+	var format = this.lookup(scope);
+
+	if (date.toString().match(/invalid/i)) {
+		return date.toString();
+	}
+
+	if (!format) {
+		return date.toString();
+	}
+
+	return this.strftime(date, format);
+};
+
+I18n.strftime = function(date, format) {
+	var options = this.lookup("date");
+
+	if (!options) {
+		return date.toString();
+	}
+
+	var weekDay = date.getDay();
+	var day = date.getDate();
+	var year = date.getFullYear();
+	var month = date.getMonth() + 1;
+	var hour = date.getHours();
+	var hour12 = hour;
+	var meridian = hour > 12? "PM" : "AM";
+	var secs = date.getSeconds();
+	var mins = date.getMinutes();
+	var offset = date.getTimezoneOffset();
+	var absOffsetHours = Math.floor(Math.abs(offset / 60));
+	var absOffsetMinutes = Math.abs(offset) - (absOffsetHours * 60);
+	var timezoneoffset = (offset > 0 ? "-" : "+") + (absOffsetHours.toString().length < 2 ? "0" + absOffsetHours : absOffsetHours) + (absOffsetMinutes.toString().length < 2 ? "0" + absOffsetMinutes : absOffsetMinutes);
+
+	if (hour12 > 12) {
+		hour12 = hour12 - 12;
+	}
+
+	var padding = function(n) {
+		var s = "0" + n.toString();
+		return s.substr(s.length - 2);
+	}
+
+	var f = format;
+	f = f.replace("%a", options["abbr_day_names"][weekDay]);
+	f = f.replace("%A", options["day_names"][weekDay]);
+	f = f.replace("%b", options["abbr_month_names"][month]);
+	f = f.replace("%B", options["month_names"][month]);
+	f = f.replace("%d", padding(day));
+	f = f.replace("%-d", day);
+	f = f.replace("%H", padding(hour));
+	f = f.replace("%-H", hour);
+	f = f.replace("%I", padding(hour12));
+	f = f.replace("%-I", hour12);
+	f = f.replace("%m", padding(month));
+	f = f.replace("%-m", month);
+	f = f.replace("%M", padding(mins));
+	f = f.replace("%-M", mins);
+	f = f.replace("%p", meridian);
+	f = f.replace("%S", padding(secs));
+	f = f.replace("%-S", secs);
+	f = f.replace("%w", weekDay);
+	f = f.replace("%y", padding(year));
+	f = f.replace("%-y", padding(year).replace(/^0+/, ""));
+	f = f.replace("%Y", year);
+	f = f.replace("%z", timezoneoffset);
+
+	return f;
+};
+
+I18n.toNumber = function(number, options) {
+	options = this.prepareOptions(
+		options,
+		this.lookup("number.format"),
+		{precision: 3, separator: ".", delimiter: ","}
+	);
+
+	var string = number.toFixed(options["precision"]).toString();
+	var parts = string.split(".");
+
+	number = parts[0];
+	var precision = parts[1];
+
+	var n = [];
+
+	while (number.length > 0) {
+		n.unshift(number.substr(Math.max(0, number.length - 3), 3));
+		number = number.substr(0, number.length -3);
+	}
+
+	var formattedNumber = n.join(options["delimiter"]);
+
+	if (options["precision"] > 0) {
+		formattedNumber += options["separator"] + parts[1];
+	}
+
+	return formattedNumber;
+};
+
+I18n.toCurrency = function(number, options) {
+	options = this.prepareOptions(
+		options,
+		this.lookup("number.currency.format"),
+		this.lookup("number.format"),
+		{unit: "$", precision: 2, format: "%u%n", delimiter: ",", separator: "."}
+	);
+
+	number = this.toNumber(number, options);
+	number = options["format"]
+		.replace("%u", options["unit"])
+		.replace("%n", number);
+
+	return number;
+};
+
+I18n.toPercentage = function(number, options) {
+	options = this.prepareOptions(
+		options,
+		this.lookup("number.percentage.format"),
+		this.lookup("number.format"),
+		{precision: 3, separator: ".", delimiter: ""}
+	);
+
+	number = this.toNumber(number, options);
+	return number + "%";
+};
+
+I18n.pluralize = function(count, scope, options) {
+	var translation = this.lookup(scope, options);
+
+	var message;
+	options = this.prepareOptions(options);
+	options["count"] = count.toString();
+
+	switch(Math.abs(count)) {
+		case 0:
+			message = translation["zero"] || translation["none"] || translation["other"] || this.missingTranslation(scope, "zero");
+			break;
+		case 1:
+			message = translation["one"] || this.missingTranslation(scope, "one");;
+			break;
+		default:
+			message = translation["other"] || this.missingTranslation(scope, "other");;
+	}
+
+	return this.interpolate(message, options);
+};
+
+I18n.missingTranslation = function() {
+	var message = '[missing "' + this.currentLocale();
+	var count = arguments.length;
+
+	for (var i = 0; i < count; i++) {
+		message += "." + arguments[i];
+	}
+
+	message += '" translation]';
+
+	return message;
+};
+
+I18n.currentLocale = function() {
+	return (I18n.locale || I18n.defaultLocale);
+};
+
+// shortcuts
+I18n.t = I18n.translate;
+I18n.l = I18n.localize;
+I18n.p = I18n.pluralize;

data/test/i18n-test.html

@@ -0,0 +1,50 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
+				"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
+<head>
+	<title>JavaScript unit test file</title>
+	<meta http-equiv="content-type" content="text/html; charset=utf-8" />
+	<script src="jsunittest/jsunittest.js" type="text/javascript"></script>
+	<link rel="stylesheet" href="jsunittest/unittest.css" type="text/css" />
+
+	<style type="text/css" media="screen">
+		#logger p {
+			background: #ffc;
+			padding: 5px;
+		}
+	</style>
+	<script type="text/javascript" charset="utf-8">
+		function log(name, message) {
+			var tag = document.getElementById("logger");
+			message = message.toString();
+			message = message.replace(/&/gm, "&amp;");
+			message = message.replace(/</gm, "&lt;");
+			message = message.replace(/>/gm, "&gt;");
+			tag.innerHTML += "<p><strong>" + name + ":</strong> " + message + "</p>";
+		}
+	</script>
+	<script src="../source/i18n.js" type="text/javascript"></script>
+</head>
+<body>
+
+<div id="content">
+	<div id="header">
+		<h1>JavaScript unit test file</h1>
+		<p>
+			This file tests <strong>i18n.js</strong>.
+		</p>
+	</div>
+
+	<!-- Log output (one per Runner, via {testLog: "testlog"} option)-->
+	<div id="testlog"></div>
+
+	<!-- General debugger -->
+	<div id="logger"></div>
+
+	<!-- Put sample/test html here -->
+	<div id="sample">
+	</div>
+</div>
+<script src="i18n-test.js" type="text/javascript" charset="utf-8"></script>
+</body>
+</html>

data/test/i18n-test.js

@@ -0,0 +1,668 @@
+new Test.Unit.Runner({
+	setup: function() {
+		I18n.defaultLocale = "en";
+		I18n.locale = null;
+
+		I18n.translations = {
+			en: {
+				hello: "Hello World!",
+				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: null
+			},
+
+			pt: {
+				hello: "Olá Mundo!",
+				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"]
+				},
+				number: {
+					percentage: {
+						format: {
+							delimiter: "",
+							separator: ",",
+							precision: 2
+						}
+					}
+				},
+				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"
+				}
+			}
+		}
+	},
+
+	teardown: function() {
+	},
+
+	// Defaults
+	testDefaults: function() { with(this) {
+		assertEqual("en", I18n.defaultLocale);
+		assertEqual(null, I18n.locale);
+		assertEqual("en", I18n.currentLocale());
+	}},
+
+	// Custom locale
+	testCustomLocale: function() { with(this) {
+		I18n.locale = "pt";
+		assertEqual("pt", I18n.currentLocale());
+	}},
+
+	// Aliases methods
+	testAliasesMethods: function() { with(this) {
+		assertEqual(I18n.translate, I18n.t);
+		assertEqual(I18n.localize, I18n.l);
+		assertEqual(I18n.pluralize, I18n.p);
+	}},
+
+	// Translation for single scope
+	testTranslationForSingleScope: function() { with(this) {
+		assertEqual("Hello World!", I18n.translate("hello"));
+	}},
+
+	// Translation as object
+	testTranslationAsObject: function() { with(this) {
+		assertEqual("object", typeof I18n.translate("greetings"));
+	}},
+
+	// Translation with invalid scope shall not block
+	testTranslationWithInvalidScope: function() { with(this) {
+		assertEqual('[missing "en.invalid.scope.shall.not.block" translation]', I18n.translate("invalid.scope.shall.not.block"));
+	}},
+
+	// Translation for single scope on a custom locale
+	testTranslationForSingleScopeOnACustomLocale: function() { with(this) {
+		I18n.locale = "pt";
+		assertEqual("Olá Mundo!", I18n.translate("hello"));
+	}},
+
+	// Translation for multiple scopes
+	testTranslationForMultipleScopes: function() { with(this) {
+		assertEqual("Hello stranger!", I18n.translate("greetings.stranger"));
+	}},
+
+	// Single interpolation
+	testSingleInterpolation: function() { with(this) {
+		actual = I18n.translate("greetings.name", {name: "John Doe"});
+		assertEqual("Hello John Doe!", actual);
+	}},
+
+	// Multiple interpolations
+	testMultipleInterpolations: function() { with(this) {
+		actual = I18n.translate("profile.details", {name: "John Doe", age: 27});
+		assertEqual("John Doe is 27-years old", actual);
+	}},
+
+	// Translation with count option
+	testTranslationWithCountOption: function() { with(this) {
+		assertEqual("You have 1 message", I18n.translate("inbox", {count: 1}));
+		assertEqual("You have 5 messages", I18n.translate("inbox", {count: 5}));
+		assertEqual("You have no messages", I18n.translate("inbox", {count: 0}));
+	}},
+
+	// Translation with count option and multiple placeholders
+	testTranslationWithCountOptionAndMultiplePlaceholders: function() { with(this) {
+		actual = I18n.translate("unread", {unread: 5, count: 1});
+		assertEqual("You have 1 new message (5 unread)", actual);
+
+		actual = I18n.translate("unread", {unread: 2, count: 10});
+		assertEqual("You have 10 new messages (2 unread)", actual);
+
+		actual = I18n.translate("unread", {unread: 5, count: 0});
+		assertEqual("You have no new messages (5 unread)", actual);
+	}},
+
+	// Missing translation with count option
+	testMissingTranslationWithCountOption: function() { with(this) {
+		actual = I18n.translate("invalid", {count: 1});
+		assertEqual('[missing "en.invalid" translation]', actual);
+
+		I18n.translations.en.inbox.one = null;
+		actual = I18n.translate("inbox", {count: 1});
+		assertEqual('[missing "en.inbox.one" translation]', actual);
+	}},
+
+	// Pluralization
+	testPluralization: function() { with(this) {
+		assertEqual("You have 1 message", I18n.pluralize(1, "inbox"));
+		assertEqual("You have 5 messages", I18n.pluralize(5, "inbox"));
+		assertEqual("You have no messages", I18n.pluralize(0, "inbox"));
+	}},
+
+	// Pluralize should return "other" scope
+	testPlurationShouldReturnOtherScope: function() { with(this) {
+		I18n.translations["en"]["inbox"]["zero"] = null;
+		assertEqual("You have 0 messages", I18n.pluralize(0, "inbox"));
+	}},
+
+	// Pluralize should return "zero" scope
+	testPlurationShouldReturnZeroScope: function() { with(this) {
+		I18n.translations["en"]["inbox"]["zero"] = "No messages (zero)";
+		I18n.translations["en"]["inbox"]["none"] = "No messages (none)";
+
+		assertEqual("No messages (zero)", I18n.pluralize(0, "inbox"));
+	}},
+
+	// Pluralize should return "none" scope
+	testPlurationShouldReturnNoneScope: function() { with(this) {
+		I18n.translations["en"]["inbox"]["zero"] = null;
+		I18n.translations["en"]["inbox"]["none"] = "No messages (none)";
+
+		assertEqual("No messages (none)", I18n.pluralize(0, "inbox"));
+	}},
+
+	// Pluralize with negative values
+	testPluralizeWithNegativeValues: function() { with(this) {
+		assertEqual("You have -1 message", I18n.pluralize(-1, "inbox"));
+		assertEqual("You have -5 messages", I18n.pluralize(-5, "inbox"));
+	}},
+
+	// Pluralize with multiple placeholders
+	testPluralizeWithMultiplePlaceholders: function() { with(this) {
+		actual = I18n.pluralize(1, "unread", {unread: 5});
+		assertEqual("You have 1 new message (5 unread)", actual);
+
+		actual = I18n.pluralize(10, "unread", {unread: 2});
+		assertEqual("You have 10 new messages (2 unread)", actual);
+
+		actual = I18n.pluralize(0, "unread", {unread: 5});
+		assertEqual("You have no new messages (5 unread)", actual);
+	}},
+
+	// Numbers with default settings
+	testNumbersWithDefaultSettings: function() { with(this) {
+		assertEqual("1.000", I18n.toNumber(1));
+		assertEqual("12.000", I18n.toNumber(12));
+		assertEqual("123.000", I18n.toNumber(123));
+		assertEqual("1,234.000", I18n.toNumber(1234));
+		assertEqual("123,456.000", I18n.toNumber(123456));
+		assertEqual("1,234,567.000", I18n.toNumber(1234567));
+		assertEqual("12,345,678.000", I18n.toNumber(12345678));
+	}},
+
+	// Numbers with partial translation and default options
+	testNumbersWithPartialTranslationAndDefaultOptions: function() { with(this) {
+		I18n.translations.en.number = {
+			format: {
+				precision: 2
+			}
+		}
+
+		assertEqual("1,234.00", I18n.toNumber(1234));
+	}},
+
+	// Numbers with full translation and default options
+	testNumbersWithFullTranslationAndDefaultOptions: function() { with(this) {
+		I18n.translations.en.number = {
+			format: {
+				delimiter: ".",
+				separator: ",",
+				precision: 2
+			}
+		}
+
+		assertEqual("1.234,00", I18n.toNumber(1234));
+	}},
+
+	// Numbers with some custom options that should be merged with default options
+	testNumbersWithSomeCustomOptionsThatShouldBeMergedWithDefaultOptions: function() { with(this) {
+		assertEqual("1,234", I18n.toNumber(1234, {precision: 0}));
+		assertEqual("1,234-000", I18n.toNumber(1234, {separator: "-"}));
+		assertEqual("1-234.000", I18n.toNumber(1234, {delimiter: "-"}));
+	}},
+
+	// Numbers considering options
+	testNumbersConsideringOptions: function() { with(this) {
+		options = {
+			precision: 2,
+			separator: ",",
+			delimiter: "."
+		};
+
+		assertEqual("1,00", I18n.toNumber(1, options));
+		assertEqual("12,00", I18n.toNumber(12, options));
+		assertEqual("123,00", I18n.toNumber(123, options));
+		assertEqual("1.234,00", I18n.toNumber(1234, options));
+		assertEqual("123.456,00", I18n.toNumber(123456, options));
+		assertEqual("1.234.567,00", I18n.toNumber(1234567, options));
+		assertEqual("12.345.678,00", I18n.toNumber(12345678, options));
+	}},
+
+	// Numbers with different precisions
+	testNumbersWithDifferentPrecisions: function() { with(this) {
+		options = {separator: ".", delimiter: ","};
+
+		options["precision"] = 2;
+		assertEqual("1.98", I18n.toNumber(1.98, options));
+
+		options["precision"] = 3;
+		assertEqual("1.980", I18n.toNumber(1.98, options));
+
+		options["precision"] = 2;
+		assertEqual("1.99", I18n.toNumber(1.987, options));
+
+		options["precision"] = 1;
+		assertEqual("2.0", I18n.toNumber(1.98, options));
+
+		options["precision"] = 0;
+		assertEqual("2", I18n.toNumber(1.98, options));
+	}},
+
+	// Currency with default settings
+	testCurrencyWithDefaultSettings: function() { with(this) {
+		assertEqual("$100.99", I18n.toCurrency(100.99));
+		assertEqual("$1,000.99", I18n.toCurrency(1000.99));
+	}},
+
+	// Current with custom settings
+	testCurrencyWithCustomSettings: function() { with(this) {
+		I18n.translations.en.number = {
+			currency: {
+				format: {
+					format: "%n %u",
+					unit: "USD",
+					delimiter: ".",
+					separator: ",",
+					precision: 2
+				}
+			}
+		};
+
+		assertEqual("12,00 USD", I18n.toCurrency(12));
+		assertEqual("123,00 USD", I18n.toCurrency(123));
+		assertEqual("1.234,56 USD", I18n.toCurrency(1234.56));
+	}},
+
+	// Currency with custom settings and partial overriding
+	testCurrencyWithCustomSettingsAndPartialOverriding: function() { with(this) {
+		I18n.translations.en.number = {
+			currency: {
+				format: {
+					format: "%n %u",
+					unit: "USD",
+					delimiter: ".",
+					separator: ",",
+					precision: 2
+				}
+			}
+		};
+
+		assertEqual("12 USD", I18n.toCurrency(12, {precision: 0}));
+		assertEqual("123,00 bucks", I18n.toCurrency(123, {unit: "bucks"}));
+	}},
+
+	// Currency with some custom options that should be merged with default options
+	testCurrencyWithSomeCustomOptionsThatShouldBeMergedWithDefaultOptions: function() { with(this) {
+		assertEqual("$1,234", I18n.toCurrency(1234, {precision: 0}));
+		assertEqual("º1,234.00", I18n.toCurrency(1234, {unit: "º"}));
+		assertEqual("$1,234-00", I18n.toCurrency(1234, {separator: "-"}));
+		assertEqual("$1-234.00", I18n.toCurrency(1234, {delimiter: "-"}));
+		assertEqual("$ 1,234.00", I18n.toCurrency(1234, {format: "%u %n"}));
+	}},
+
+	// Localize numbers
+	testLocalizeNumbers: function() { with(this) {
+		assertEqual("1,234,567.000", I18n.localize("number", 1234567));
+	}},
+
+	// Localize currency
+	testLocalizeCurrency: function() { with(this) {
+		assertEqual("$1,234,567.00", I18n.localize("currency", 1234567));
+	}},
+
+	// Parse date
+	testParseDate: function() { with(this) {
+		expected = new Date(2009, 0, 24, 0, 0, 0);
+		assertEqual(expected.toString(), I18n.parseDate("2009-01-24").toString());
+
+		expected = new Date(2009, 0, 24, 0, 15, 0);
+		assertEqual(expected.toString(), I18n.parseDate("2009-01-24 00:15:00").toString());
+
+		expected = new Date(2009, 0, 24, 0, 0, 15);
+		assertEqual(expected.toString(), I18n.parseDate("2009-01-24 00:00:15").toString());
+
+		expected = new Date(2009, 0, 24, 15, 33, 44);
+		assertEqual(expected.toString(), I18n.parseDate("2009-01-24 15:33:44").toString());
+
+		expected = new Date(2009, 0, 24, 0, 0, 0);
+		assertEqual(expected.toString(), I18n.parseDate(expected.getTime()).toString());
+
+		expected = new Date(2009, 0, 24, 0, 0, 0);
+		assertEqual(expected.toString(), I18n.parseDate("01/24/2009").toString());
+
+		expected = new Date(2009, 0, 24, 14, 33, 55);
+		assertEqual(expected.toString(), I18n.parseDate(expected).toString());
+
+		expected = new Date(2009, 0, 24, 15, 33, 44);
+		assertEqual(expected.toString(), I18n.parseDate("2009-01-24T15:33:44").toString());
+
+		expected = new Date(Date.UTC(2009, 0, 24, 15, 33, 44));
+		assertEqual(expected.toString(), I18n.parseDate("2009-01-24T15:33:44Z").toString());
+	}},
+
+	// Date formatting
+	testDateFormatting: function() { with(this) {
+		I18n.locale = "pt";
+
+		// 2009-04-26 19:35:44 (Sunday)
+		var date = new Date(2009, 3, 26, 19, 35, 44);
+
+		// short week day
+		assertEqual("Dom", I18n.strftime(date, "%a"));
+
+		// full week day
+		assertEqual("Domingo", I18n.strftime(date, "%A"));
+
+		// short month
+		assertEqual("Abr", I18n.strftime(date, "%b"));
+
+		// full month
+		assertEqual("Abril", I18n.strftime(date, "%B"));
+
+		// day
+		assertEqual("26", I18n.strftime(date, "%d"));
+
+		// 24-hour
+		assertEqual("19", I18n.strftime(date, "%H"));
+
+		// 12-hour
+		assertEqual("07", I18n.strftime(date, "%I"));
+
+		// month
+		assertEqual("04", I18n.strftime(date, "%m"));
+
+		// minutes
+		assertEqual("35", I18n.strftime(date, "%M"));
+
+		// meridian
+		assertEqual("PM", I18n.strftime(date, "%p"));
+
+		// seconds
+		assertEqual("44", I18n.strftime(date, "%S"));
+
+		// week day
+		assertEqual("0", I18n.strftime(date, "%w"));
+
+		// short year
+		assertEqual("09", I18n.strftime(date, "%y"));
+
+		// full year
+		assertEqual("2009", I18n.strftime(date, "%Y"));
+	}},
+
+	// Date formatting without padding
+	testDateFormattingWithoutPadding: function() { with(this) {
+		I18n.locale = "pt";
+
+		// 2009-04-26 19:35:44 (Sunday)
+		var date = new Date(2009, 3, 9, 7, 8, 9);
+
+		// 24-hour without padding
+		assertEqual("7", I18n.strftime(date, "%-H"));
+
+		// 12-hour without padding
+		assertEqual("7", I18n.strftime(date, "%-I"));
+
+		// minutes without padding
+		assertEqual("8", I18n.strftime(date, "%-M"));
+
+		// seconds without padding
+		assertEqual("9", I18n.strftime(date, "%-S"));
+
+		// short year without padding
+		assertEqual("9", I18n.strftime(date, "%-y"));
+
+		// month without padding
+		assertEqual("4", I18n.strftime(date, "%-m"));
+
+		// day without padding
+		assertEqual("9", I18n.strftime(date, "%-d"));
+	}},
+
+	// Date formatting with padding
+	testDateFormattingWithPadding: function() { with(this) {
+		I18n.locale = "pt";
+
+		// 2009-04-26 19:35:44 (Sunday)
+		var date = new Date(2009, 3, 9, 7, 8, 9);
+
+		// 24-hour
+		assertEqual("07", I18n.strftime(date, "%H"));
+
+		// 12-hour
+		assertEqual("07", I18n.strftime(date, "%I"));
+
+		// minutes
+		assertEqual("08", I18n.strftime(date, "%M"));
+
+		// seconds
+		assertEqual("09", I18n.strftime(date, "%S"));
+
+		// short year
+		assertEqual("09", I18n.strftime(date, "%y"));
+
+		// month
+		assertEqual("04", I18n.strftime(date, "%m"));
+
+		// day
+		assertEqual("09", I18n.strftime(date, "%d"));
+	}},
+
+	// Date formatting with negative Timezone
+	testDateFormattingWithNegativeTimezone: function() { with(this) {
+		I18n.locale = "pt";
+
+		var date = new Date(2009, 3, 26, 19, 35, 44);
+
+		date.getTimezoneOffset = function() {
+			return 345;
+		};
+
+		assertMatch(/^(\+|-)[\d]{4}$/, I18n.strftime(date, "%z"));
+		assertEqual("-0545", I18n.strftime(date, "%z"));
+	}},
+
+	// Date formatting with positive Timezone
+	testDateFormattingWithPositiveTimezone: function() { with(this) {
+		I18n.locale = "pt";
+
+		var date = new Date(2009, 3, 26, 19, 35, 44);
+
+		date.getTimezoneOffset = function() {
+			return -345;
+		};
+
+		assertMatch(/^(\+|-)[\d]{4}$/, I18n.strftime(date, "%z"));
+		assertEqual("+0545", I18n.strftime(date, "%z"));
+	}},
+
+	// Localize date strings
+	testLocalizeDateStrings: function() { with(this) {
+		I18n.locale = "pt";
+
+		assertEqual("29/11/2009", I18n.localize("date.formats.default", "2009-11-29"));
+		assertEqual("07 de Janeiro", I18n.localize("date.formats.short", "2009-01-07"));
+		assertEqual("07 de Janeiro de 2009", I18n.localize("date.formats.long", "2009-01-07"));
+	}},
+
+	// Localize time strings
+	testLocalizeTimeStrings: function() { with(this) {
+		I18n.locale = "pt";
+		assertEqual("Domingo, 29 de Novembro de 2009, 15:07 h", I18n.localize("time.formats.default", "2009-11-29 15:07:59"));
+		assertEqual("07/01, 09:12 h", I18n.localize("time.formats.short", "2009-01-07 09:12:35"));
+		assertEqual("Domingo, 29 de Novembro de 2009, 15:07 h", I18n.localize("time.formats.long", "2009-11-29 15:07:59"));
+	}},
+
+	// Localize percentage
+	testLocalizePercentage: function() { with(this) {
+		I18n.locale = "pt";
+		assertEqual("123,45%", I18n.localize("percentage", 123.45));
+	}},
+
+
+
+	// Default value for simple translation
+	testDefaultValueForSimpleTranslation: function() { with(this) {
+		actual = I18n.translate("warning", {defaultValue: "Warning!"});
+		assertEqual("Warning!", actual);
+	}},
+
+	// Default value with interpolation
+	testDefaultValueWithInterpolation: function() { with(this) {
+		actual = I18n.translate("alert", {defaultValue: "Attention! {{message}}", message: "You're out of quota!"});
+		assertEqual("Attention! You're out of quota!", actual);
+	}},
+
+	// Default value should not be used when scope exist
+	testDefaultValueShouldNotBeUsedWhenScopeExist: function() { with(this) {
+		actual = I18n.translate("hello", {defaultValue: "What's up?"});
+		assertEqual("Hello World!", actual);
+	}},
+
+	// Default value for pluralize
+	testDefaultValueForPluralize: function() { with(this) {
+		options = {defaultValue: {
+			none: "No things here!",
+			one: "There is {{count}} thing here!",
+			other: "There are {{count}} things here!"
+		}};
+
+		assertEqual("No things here!", I18n.pluralize(0, "things", options));
+		assertEqual("There is 1 thing here!", I18n.pluralize(1, "things", options));
+		assertEqual("There are 5 things here!", I18n.pluralize(5, "things", options));
+	}},
+
+	// Default value for pluralize should not be used when scope exist
+	testDefaultValueForPluralizeShouldNotBeUsedWhenScopeExist: function() { with(this) {
+		options = {defaultValue: {
+			none: "No things here!",
+			one: "There is {{count}} thing here!",
+			other: "There are {{count}} things here!"
+		}};
+
+		assertEqual("You have no messages", I18n.pluralize(0, "inbox", options));
+		assertEqual("You have 1 message", I18n.pluralize(1, "inbox", options));
+		assertEqual("You have 5 messages", I18n.pluralize(5, "inbox", options));
+	}},
+
+	// Prepare options
+	testPrepareOptions: function() { with(this) {
+		options = I18n.prepareOptions(
+			{name: "Mary Doe"},
+			{name: "John Doe", role: "user"}
+		);
+
+		assertEqual("Mary Doe", options["name"]);
+		assertEqual("user", options["role"]);
+	}},
+
+	// Prepare options with multiple options
+	testPrepareOptionsWithMultipleOptions: function() { with(this) {
+		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"}
+		);
+
+		assertEqual("Mary Doe", options["name"]);
+		assertEqual("user", options["role"]);
+		assertEqual(33, options["age"]);
+		assertEqual("mary@doe.com", options["email"]);
+		assertEqual("http://marydoe.com", options["url"]);
+	}},
+
+	// Prepare options should return an empty hash when values are null
+	testPrepareOptionsShouldReturnAnEmptyHashWhenValuesAreNull: function() { with(this) {
+		assertNotNullOrUndefined(I18n.prepareOptions(null, null));
+	}},
+
+	// Percentage with defaults
+	testPercentageWithDefaults: function() { with(this) {
+		assertEqual("1234.000%", I18n.toPercentage(1234));
+	}},
+
+	// Percentage with custom options
+	testPercentageWithCustomOptions: function() { with(this) {
+		assertEqual("1_234%", I18n.toPercentage(1234, {delimiter: "_", precision: 0}));
+	}},
+
+	// Percentage with translation
+	testPercentageWithTranslation: function() { with(this) {
+		I18n.translations.en.number = {
+			percentage: {
+				format: {
+					precision: 2,
+					delimiter: ".",
+					separator: ","
+				}
+			}
+		}
+
+		assertEqual("1.234,00%", I18n.toPercentage(1234));
+	}},
+
+	// Percentage with translation and custom options
+	testPercentageWithTranslationAndCustomOptions: function() { with(this) {
+		I18n.translations.en.number = {
+			percentage: {
+				format: {
+					precision: 2,
+					delimiter: ".",
+					separator: ","
+				}
+			}
+		}
+
+		assertEqual("1-234+0000%", I18n.toPercentage(1234, {precision: 4, delimiter: "-", separator: "+"}));
+	}},
+
+	// Scope option as string
+	testScopeOptionAsString: function() { with(this) {
+		actual = I18n.translate("stranger", {scope: "greetings"});
+		assertEqual("Hello stranger!", actual);
+	}},
+
+	// Scope as array
+	testScopeAsArray: function() { with(this) {
+		actual = I18n.translate(["greetings", "stranger"]);
+		assertEqual("Hello stranger!", actual);
+	}},
+
+	// New placeholder syntax
+	testNewPlaceholderSyntax: function() { with(this) {
+		I18n.translations["en"]["new_syntax"] = "Hi %{name}!";
+		actual = I18n.translate("new_syntax", {name: "John"});
+		assertEqual("Hi John!", actual);
+	}}
+});