socialcast-i18n-js 4.0.0.rc1 → 4.0.0.rc2

data/vendor/assets/javascripts/i18n.js

@@ -1,531 +1,661 @@
-// https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/indexOf
-if (!Array.prototype.indexOf) {
-  Array.prototype.indexOf = function(searchElement /*, fromIndex */) {
-    "use strict";
+//= require underscore
 
-    if (this === void 0 || this === null) {
-      throw new TypeError();
+// I18n.js
+// =======
+//
+// This small library provides the Rails I18n API on the Javascript.
+//
+var I18n = {};
+
+;(function(I18n){
+  "use strict";
+
+  I18n.reset = function() {
+    // Set default locale. This locale will be used when fallback is enabled and
+    // the translation doesn't exist in a particular locale.
+    this.defaultLocale = "en";
+
+    // Set the current locale to `en`.
+    this.locale = "en";
+
+    // Set the translation key separator.
+    this.defaultSeparator = ".";
+
+    // Set the placeholder format. Accepts `{{placeholder}}` and `%{placeholder}`.
+    this.placeholder = /(?:\{\{|%\{)(.*?)(?:\}\}?)/gm;
+
+    // Set if engine should fallback to the default locale when a translation
+    // is missing.
+    this.fallbacks = false;
+
+    // Set the default translation object.
+    this.translations = {};
+  };
+
+  // Return a list of all locales that must be tried before returning the
+  // missing translation message. By default, this will consider the inline option,
+  // current locale and fallback locale.
+  //
+  //     I18n.locales.get("de-DE");
+  //     // ["de-DE", "de", "en"]
+  //
+  // You can define custom rules for any locale. Just make sure you return a array
+  // containing all locales.
+  //
+  //     // Default the Wookie locale to English.
+  //     I18n.locales["wk"] = function(locale) {
+  //       return ["en"];
+  //     };
+  //
+  I18n.locales = {};
+
+  // Retrieve locales based on inline locale, current locale or default to
+  // I18n's detection.
+  I18n.locales.get = function(locale) {
+    var result = this[locale] || this[I18n.locale] || this["default"];
+
+    if (_.isFunction(result)) {
+      result = result(locale);
     }
 
-    var t = Object(this);
-    var len = t.length >>> 0;
+    if (!_.isArray(result)) {
+      result = [result];
+    }
+
+    return result;
+  };
 
-    if (len === 0) {
-      return -1;
+  // The default locale list.
+  I18n.locales["default"] = function(locale) {
+    var locales = []
+      , list = []
+      , countryCode
+      , count
+    ;
+
+    // Handle the inline locale option that can be provided to
+    // the `I18n.t` options.
+    if (locale) {
+      locales.push(locale);
     }
 
-    var n = 0;
-    if (arguments.length > 0) {
-      n = Number(arguments[1]);
-      if (n !== n) { // shortcut for verifying if it's NaN
-        n = 0;
-      } else if (n !== 0 && n !== (Infinity) && n !== -(Infinity)) {
-        n = (n > 0 || -1) * Math.floor(Math.abs(n));
-      }
+    // Add the current locale to the list.
+    if (!locale && I18n.locale) {
+      locales.push(I18n.locale);
     }
 
-    if (n >= len) {
-      return -1;
+    // Add the default locale if fallback strategy is enabled.
+    if (I18n.fallbacks && I18n.defaultLocale) {
+      locales.push(I18n.defaultLocale);
     }
 
-    var k = n >= 0
-          ? n
-          : Math.max(len - Math.abs(n), 0);
+    // Compute each locale with its country code.
+    // So this will return an array containing both
+    // `de-DE` and `de` locales.
+    locales.forEach(function(locale){
+      countryCode = locale.split("-")[0];
+
+      if (!_.include(list, locale)) {
+        list.push(locale);
+      }
 
-    for (; k < len; k++) {
-      if (k in t && t[k] === searchElement) {
-        return k;
+      if (I18n.fallbacks && countryCode && countryCode !== locale && !_.include(list, countryCode)) {
+        list.push(countryCode);
       }
+    });
+
+    // No locales set? English it is.
+    if (!locales.length) {
+      locales.push("en");
     }
 
-    return -1;
+    return list;
   };
-}
 
-// Instantiate the object
-var I18n = I18n || {};
+  //
+  //
+  I18n.pluralization = {};
 
-// Set default locale to english
-I18n.defaultLocale = "en";
+  // Return the pluralizer for a specific locale.
+  // If no specify locale is found, then I18n's default will be used.
+  I18n.pluralization.get = function(locale) {
+    return this[locale] || this[I18n.locale] || this["default"];
+  };
 
-// Set default handling of translation fallbacks to false
-I18n.fallbacks = false;
+  // The default pluralizer rule.
+  // It detects the `zero`, `one`, and `other` scopes.
+  I18n.pluralization["default"] = function(count) {
+    switch (count) {
+      case 0: return ["zero", "other"];
+      case 1: return ["one"];
+      default: return ["other"];
+    }
+  };
 
-// Set default separator
-I18n.defaultSeparator = ".";
+  // Reset all default attributes. This is specially useful
+  // while running tests.
+  I18n.reset();
 
-// Set current locale to null
-I18n.locale = null;
+  // Return current locale. If no locale has been set, then
+  // the current locale will be the default locale.
+  I18n.currentLocale = function() {
+    return this.locale || this.defaultLocale;
+  };
+
+  // Check if value is different than undefined and null;
+  I18n.isSet = function(value) {
+    return !_.isUndefined(value) && !_.isNull(value);
+  };
 
-// Set the placeholder format. Accepts `{{placeholder}}` and `%{placeholder}`.
-I18n.PLACEHOLDER = /(?:\{\{|%\{)(.*?)(?:\}\}?)/gm;
+  // Find and process the translation using the provided scope and options.
+  // This is used internally by some functions and should not be used as an
+  // public API.
+  I18n.lookup = function(scope, options) {
+    options = this.prepareOptions(options);
+
+    var locales = this.locales.get(options.locale)
+      , requestedLocale = locales[0]
+      , locale
+      , scopes
+      , translations
+    ;
+
+    while (locales.length) {
+      locale = locales.shift();
+      scopes = scope.split(this.defaultSeparator);
+      translations = this.translations[locale];
+
+      if (_.isUndefined(translations)) {
+        continue;
+      }
 
-I18n.fallbackRules = {
-};
+      while (scopes.length) {
+        translations = translations[scopes.shift()];
 
-I18n.pluralizationRules = {
-  en: function (n) {
-    return n == 0 ? ["zero", "none", "other"] : n == 1 ? "one" : "other";
-  }
-};
+        if (_.isUndefined(translations)) {
+          break;
+        }
+      }
 
-I18n.getFallbacks = function(locale) {
-  if (locale === I18n.defaultLocale) {
-    return [];
-  } else if (!I18n.fallbackRules[locale]) {
-    var rules = []
-      , components = locale.split("-");
+      if (!_.isUndefined(translations)) {
+        return translations;
+      }
+    }
 
-    for (var l = 1; l < components.length; l++) {
-      rules.push(components.slice(0, l).join("-"));
+    if (this.isSet(options.defaultValue)) {
+      return options.defaultValue;
     }
+  };
 
-    rules.push(I18n.defaultLocale);
+  // 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 args = Array.prototype.slice.call(arguments)
+      , options = {}
+    ;
 
-    I18n.fallbackRules[locale] = rules;
-  }
+    for (var i = 0, count = args.length; i < count; i++) {
+      var o = args.shift();
 
-  return I18n.fallbackRules[locale];
-}
+      if (!_.isObject(o)) {
+        continue;
+      }
 
-I18n.isValidNode = function(obj, node, undefined) {
-  return obj[node] !== null && obj[node] !== undefined;
-};
-
-I18n.lookup = function(scope, options) {
-  var options = options || {}
-    , lookupInitialScope = scope
-    , translations = this.prepareOptions(I18n.translations)
-    , locale = options.locale || I18n.currentLocale()
-    , messages = translations[locale] || {}
-    , options = this.prepareOptions(options)
-    , currentScope
-  ;
-
-  if (typeof(scope) == "object") {
-    scope = scope.join(this.defaultSeparator);
-  }
-
-  if (options.scope) {
-    scope = options.scope.toString() + this.defaultSeparator + scope;
-  }
-
-  scope = scope.split(this.defaultSeparator);
-
-  while (messages && scope.length > 0) {
-    currentScope = scope.shift();
-    messages = messages[currentScope];
-  }
-
-  if (!messages) {
-    if (I18n.fallbacks) {
-      var fallbacks = this.getFallbacks(locale);
-      for (var fallback = 0; fallback < fallbacks.length; fallbacks++) {
-        messages = I18n.lookup(lookupInitialScope, this.prepareOptions({locale: fallbacks[fallback]}, options));
-        if (messages) {
-          break;
+      for (var attr in o) {
+        if (!_.has(o, attr)) {
+          continue;
         }
+
+        if (this.isSet(options[attr])) {
+          continue;
+        }
+
+        options[attr] = o[attr];
       }
     }
 
-    if (!messages && this.isValidNode(options, "defaultValue")) {
-        messages = options.defaultValue;
+    return options;
+  };
+
+  // Translate the given scope with the provided options.
+  I18n.translate = function(scope, options) {
+    options = this.prepareOptions(options);
+    var translation = this.lookup(scope, options);
+
+    if (_.isUndefined(translation)) {
+      return this.missingTranslation(scope);
     }
-  }
 
-  return messages;
-};
+    if (_.isString(translation)) {
+      translation = this.interpolate(translation, options);
+    } else if (_.isObject(translation) && this.isSet(options.count)) {
+      translation = this.pluralize(options.count, translation, options);
+    }
 
-// 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 = {}
-    , opts
-    , count = arguments.length
-  ;
+    return translation;
+  };
 
-  for (var i = 0; i < count; i++) {
-    opts = arguments[i];
+  // This function interpolates the all variables in the given message.
+  I18n.interpolate = function(message, options) {
+    options = this.prepareOptions(options);
+    var matches = message.match(this.placeholder)
+      , placeholder
+      , value
+      , name
+      , regex
+    ;
 
-    if (!opts) {
-      continue;
+    if (!matches) {
+      return message;
     }
 
-    for (var key in opts) {
-      if (!this.isValidNode(options, key)) {
-        options[key] = opts[key];
+    while (matches.length) {
+      placeholder = matches.shift();
+      name = placeholder.replace(this.placeholder, "$1");
+      value = options[name];
+
+      if (!this.isSet(options[name])) {
+        value = "[missing " + placeholder + " value]";
       }
+
+      regex = new RegExp(placeholder.replace(/\{/gm, "\\{").replace(/\}/gm, "\\}"));
+      message = message.replace(regex, value);
     }
-  }
 
-  return options;
-};
+    return message;
+  };
+
+  // Pluralize the given scope using the `count` value.
+  // The pluralized translation may have other placeholders,
+  // which will be retrieved from `options`.
+  I18n.pluralize = function(count, scope, options) {
+    options = this.prepareOptions(options);
+    var translations, pluralizer, keys, key, message;
 
-I18n.interpolate = function(message, options) {
-  options = this.prepareOptions(options);
-  var matches = message.match(this.PLACEHOLDER)
-    , placeholder
-    , value
-    , name
-  ;
+    if (_.isObject(scope)) {
+      translations = scope;
+    } else {
+      translations = this.lookup(scope, options);
+    }
+
+    if (_.isUndefined(translations)) {
+      return this.missingTranslation(scope);
+    }
+
+    pluralizer = this.pluralization.get(options.locale);
+    keys = pluralizer(Math.abs(count));
+
+    while (keys.length) {
+      key = keys.shift();
+
+      if (this.isSet(translations[key])) {
+        message = translations[key];
+        break;
+      }
+    }
+
+    options.count = String(count);
+    return this.interpolate(message, options);
+  };
+
+  // Return a missing translation message for the given parameters.
+  I18n.missingTranslation = function(scope) {
+    var message = '[missing "' + this.currentLocale();
+
+    for (var i = 0; i < arguments.length; i++) {
+      message += "." + arguments[i];
+    }
+
+    message += '" translation]';
 
-  if (!matches) {
     return message;
-  }
+  };
+
+  // Format number using localization rules.
+  // The options will be retrieved from the `number.format` scope.
+  // If this isn't present, then the following options will be used:
+  //
+  // - `precision`: `3`
+  // - `separator`: `"."`
+  // - `delimiter`: `","`
+  // - `strip_insignificant_zeros`: `false`
+  //
+  // You can also override these options by providing the `options` argument.
+  //
+  I18n.toNumber = function(number, options) {
+    options = this.prepareOptions(
+      options,
+      this.lookup("number.format"),
+      {precision: 3, separator: ".", delimiter: ",", strip_insignificant_zeros: false}
+    );
+
+    var negative = number < 0
+      , string = Math.abs(number).toFixed(options.precision).toString()
+      , parts = string.split(".")
+      , precision
+      , buffer = []
+      , formattedNumber
+    ;
 
-  for (var i = 0; placeholder = matches[i]; i++) {
-    name = placeholder.replace(this.PLACEHOLDER, "$1");
+    number = parts[0];
+    precision = parts[1];
 
-    value = options[name];
+    while (number.length > 0) {
+      buffer.unshift(number.substr(Math.max(0, number.length - 3), 3));
+      number = number.substr(0, number.length -3);
+    }
+
+    formattedNumber = buffer.join(options.delimiter);
 
-    if (!this.isValidNode(options, name)) {
-      value = "[missing " + placeholder + " value]";
+    if (options.precision > 0) {
+      formattedNumber += options.separator + parts[1];
     }
 
-    regex = new RegExp(placeholder.replace(/\{/gm, "\\{").replace(/\}/gm, "\\}"));
-    message = message.replace(regex, value);
-  }
+    if (negative) {
+      formattedNumber = "-" + formattedNumber;
+    }
+
+    if (options.strip_insignificant_zeros) {
+      var regex = {
+          separator: new RegExp(options.separator.replace(/\./, "\\.") + "$")
+        , zeros: /0+$/
+      };
+
+      formattedNumber = formattedNumber
+        .replace(regex.zeros, "")
+        .replace(regex.separator, "")
+      ;
+    }
 
-  return message;
-};
+    return formattedNumber;
+  };
 
-I18n.translate = function(scope, options) {
-  options = this.prepareOptions(options);
-  var translation = this.lookup(scope, options);
+  // Format currency with localization rules.
+  // The options will be retrieved from the `number.currency.format` and
+  // `number.format` scopes, in that order.
+  //
+  // Any missing option will be retrieved from the `I18n.toNumber` defaults and
+  // the following options:
+  //
+  // - `unit`: `"$"`
+  // - `precision`: `2`
+  // - `format`: `"%u%n"`
+  // - `delimiter`: `","`
+  // - `separator`: `"."`
+  //
+  // You can also override these options by providing the `options` argument.
+  //
+  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;
+  };
+
+  // Localize several values.
+  // You can provide the following scopes: `currency`, `number`, or `percentage`.
+  // If you provide a scope that matches the `/^(date|time)/` regular expression
+  // then the `value` will be converted by using the `I18n.toTime` function.
+  //
+  // It will default to the value's `toString` function.
+  //
+  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();
+        }
+    }
+  };
+
+  // Parse a given `date` string into a JavaScript Date object.
+  // This function is time zone aware.
+  //
+  // The following string formats are recognized:
+  //
+  //    yyyy-mm-dd
+  //    yyyy-mm-dd[ T]hh:mm::ss
+  //    yyyy-mm-dd[ T]hh:mm::ss
+  //    yyyy-mm-dd[ T]hh:mm::ssZ
+  //    yyyy-mm-dd[ T]hh:mm::ss+0000
+  //
+  I18n.parseDate = function(date) {
+    var matches, convertedDate;
+
+    // we have a date, so just return it.
+    if (_.isDate(date)) {
+      return date;
+    };
+
+    matches = date.toString().match(/(\d{4})-(\d{2})-(\d{2})(?:[ T](\d{2}):(\d{2}):(\d{2}))?(Z|\+0000)?/);
+
+    if (matches) {
+      for (var i = 1; i <= 6; i++) {
+        matches[i] = parseInt(matches[i], 10) || 0;
+      }
 
-  try {
-    if (typeof(translation) == "object") {
-      if (typeof(options.count) == "number") {
-        return this.pluralize(options.count, scope, options);
+      // month starts on 0
+      matches[2] -= 1;
+
+      if (matches[7]) {
+        convertedDate = new Date(Date.UTC(matches[1], matches[2], matches[3], matches[4], matches[5], matches[6]));
       } else {
-        return translation;
+        convertedDate = new Date(matches[1], matches[2], matches[3], matches[4], matches[5], matches[6]);
       }
+    } else if (typeof(date) == "number") {
+      // UNIX timestamp
+      convertedDate = new Date();
+      convertedDate.setTime(date);
+    } else if (date.match(/\d+ \d+:\d+:\d+ [+-]\d+ \d+/)) {
+      // a valid javascript format with timezone info
+      convertedDate = new Date();
+      convertedDate.setTime(Date.parse(date))
     } else {
-      return this.interpolate(translation, options);
+      // an arbitrary javascript string
+      convertedDate = new Date();
+      convertedDate.setTime(Date.parse(date));
     }
-  } 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();
+
+    return convertedDate;
+  };
+
+  // Formats time according to the directives in the given format string.
+  // The directives begins with a percent (%) character. Any text not listed as a
+  // directive will be passed through to the output string.
+  //
+  // The accepted formats are:
+  //
+  //     %a  - The abbreviated weekday name (Sun)
+  //     %A  - The full weekday name (Sunday)
+  //     %b  - The abbreviated month name (Jan)
+  //     %B  - The full month name (January)
+  //     %c  - The preferred local date and time representation
+  //     %d  - Day of the month (01..31)
+  //     %-d - Day of the month (1..31)
+  //     %H  - Hour of the day, 24-hour clock (00..23)
+  //     %-H - Hour of the day, 24-hour clock (0..23)
+  //     %I  - Hour of the day, 12-hour clock (01..12)
+  //     %-I - Hour of the day, 12-hour clock (1..12)
+  //     %m  - Month of the year (01..12)
+  //     %-m - Month of the year (1..12)
+  //     %M  - Minute of the hour (00..59)
+  //     %-M - Minute of the hour (0..59)
+  //     %p  - Meridian indicator (AM  or  PM)
+  //     %S  - Second of the minute (00..60)
+  //     %-S - Second of the minute (0..60)
+  //     %w  - Day of the week (Sunday is 0, 0..6)
+  //     %y  - Year without a century (00..99)
+  //     %-y - Year without a century (0..99)
+  //     %Y  - Year with century
+  //     %z  - Timezone offset (+0545)
+  //
+  I18n.strftime = function(date, format) {
+    var options = this.lookup("date");
+
+    if (!options) {
+      options = {
+          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", "Sep", "Oct", "Nov", "Dec"]
       }
-  }
-};
+    }
 
-I18n.parseDate = function(date) {
-  var matches, convertedDate;
+    if (!options.meridian) {
+      options.meridian = ["AM", "PM"];
+    }
 
-  // we have a date, so just return it.
-  if (typeof(date) == "object") {
-    return date;
+    var weekDay = date.getDay()
+      , day = date.getDate()
+      , year = date.getFullYear()
+      , month = date.getMonth() + 1
+      , hour = date.getHours()
+      , hour12 = hour
+      , meridian = hour > 11 ? 1 : 0
+      , secs = date.getSeconds()
+      , mins = date.getMinutes()
+      , offset = date.getTimezoneOffset()
+      , absOffsetHours = Math.floor(Math.abs(offset / 60))
+      , absOffsetMinutes = Math.abs(offset) - (absOffsetHours * 60)
+      , timezoneoffset = (offset > 0 ? "-" : "+") + (absOffsetHours.toString().length < 2 ? "0" + absOffsetHours : absOffsetHours) + (absOffsetMinutes.toString().length < 2 ? "0" + absOffsetMinutes : absOffsetMinutes)
+    ;
+
+    if (hour12 > 12) {
+      hour12 = hour12 - 12;
+    } else if (hour12 === 0) {
+      hour12 = 12;
+    }
+
+    var padding = function(n) {
+      var s = "0" + n.toString();
+      return s.substr(s.length - 2);
+    };
+
+    format = format.replace("%a", options.abbr_day_names[weekDay]);
+    format = format.replace("%A", options.day_names[weekDay]);
+    format = format.replace("%b", options.abbr_month_names[month]);
+    format = format.replace("%B", options.month_names[month]);
+    format = format.replace("%d", padding(day));
+    format = format.replace("%e", day);
+    format = format.replace("%-d", day);
+    format = format.replace("%H", padding(hour));
+    format = format.replace("%-H", hour);
+    format = format.replace("%I", padding(hour12));
+    format = format.replace("%-I", hour12);
+    format = format.replace("%m", padding(month));
+    format = format.replace("%-m", month);
+    format = format.replace("%M", padding(mins));
+    format = format.replace("%-M", mins);
+    format = format.replace("%p", options.meridian[meridian]);
+    format = format.replace("%S", padding(secs));
+    format = format.replace("%-S", secs);
+    format = format.replace("%w", weekDay);
+    format = format.replace("%y", padding(year));
+    format = format.replace("%-y", padding(year).replace(/^0+/, ""));
+    format = format.replace("%Y", year);
+    format = format.replace("%z", timezoneoffset);
+
+    return format;
   };
 
-  // it matches the following formats:
-  //   yyyy-mm-dd
-  //   yyyy-mm-dd[ T]hh:mm::ss
-  //   yyyy-mm-dd[ T]hh:mm::ss
-  //   yyyy-mm-dd[ T]hh:mm::ssZ
-  //   yyyy-mm-dd[ T]hh:mm::ss+0000
   //
-  matches = date.toString().match(/(\d{4})-(\d{2})-(\d{2})(?:[ T](\d{2}):(\d{2}):(\d{2}))?(Z|\+0000)?/);
+  //
+  I18n.toTime = function(scope, d) {
+    var date = this.parseDate(d)
+      , format = this.lookup(scope)
+    ;
+
+    if (date.toString().match(/invalid/i)) {
+      return date.toString();
+    }
 
-  if (matches) {
-    for (var i = 1; i <= 6; i++) {
-      matches[i] = parseInt(matches[i], 10) || 0;
+    if (!format) {
+      return date.toString();
     }
 
-    // month starts on 0
-    matches[2] -= 1;
+    return this.strftime(date, format);
+  };
+
+  //
+  //
+  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.toHumanSize = function(number, options) {
+    var kb = 1024
+      , size = number
+      , iterations = 0
+      , unit
+      , precision
+    ;
 
-    if (matches[7]) {
-      convertedDate = new Date(Date.UTC(matches[1], matches[2], matches[3], matches[4], matches[5], matches[6]));
+    while (size >= kb && iterations < 4) {
+      size = size / kb;
+      iterations += 1;
+    }
+
+    if (iterations === 0) {
+      unit = this.t("number.human.storage_units.units.byte", {count: size});
+      precision = 0;
     } else {
-      convertedDate = new Date(matches[1], matches[2], matches[3], matches[4], matches[5], matches[6]);
+      unit = this.t("number.human.storage_units.units." + [null, "kb", "mb", "gb", "tb"][iterations]);
+      precision = (size - Math.floor(size) === 0) ? 0 : 1;
     }
-  } else if (typeof(date) == "number") {
-    // UNIX timestamp
-    convertedDate = new Date();
-    convertedDate.setTime(date);
-  } else if (date.match(/\d+ \d+:\d+:\d+ [+-]\d+ \d+/)) {
-    // a valid javascript format with timezone info
-    convertedDate = new Date();
-    convertedDate.setTime(Date.parse(date))
-  } else {
-    // an arbitrary javascript string
-    convertedDate = new Date();
-    convertedDate.setTime(Date.parse(date));
-  }
-
-  return convertedDate;
-};
-
-I18n.toTime = function(scope, d) {
-  var date = this.parseDate(d)
-    , 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();
-  }
-
-  options.meridian = options.meridian || ["AM", "PM"];
-
-  var weekDay = date.getDay()
-    , day = date.getDate()
-    , year = date.getFullYear()
-    , month = date.getMonth() + 1
-    , hour = date.getHours()
-    , hour12 = hour
-    , meridian = hour > 11 ? 1 : 0
-    , secs = date.getSeconds()
-    , mins = date.getMinutes()
-    , offset = date.getTimezoneOffset()
-    , absOffsetHours = Math.floor(Math.abs(offset / 60))
-    , absOffsetMinutes = Math.abs(offset) - (absOffsetHours * 60)
-    , timezoneoffset = (offset > 0 ? "-" : "+") + (absOffsetHours.toString().length < 2 ? "0" + absOffsetHours : absOffsetHours) + (absOffsetMinutes.toString().length < 2 ? "0" + absOffsetMinutes : absOffsetMinutes)
-  ;
-
-  if (hour12 > 12) {
-    hour12 = hour12 - 12;
-  } else if (hour12 === 0) {
-    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("%e", 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", options.meridian[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: ",", strip_insignificant_zeros: false}
-  );
-
-  var negative = number < 0
-    , string = Math.abs(number).toFixed(options.precision).toString()
-    , parts = string.split(".")
-    , precision
-    , buffer = []
-    , formattedNumber
-  ;
-
-  number = parts[0];
-  precision = parts[1];
-
-  while (number.length > 0) {
-    buffer.unshift(number.substr(Math.max(0, number.length - 3), 3));
-    number = number.substr(0, number.length -3);
-  }
-
-  formattedNumber = buffer.join(options.delimiter);
-
-  if (options.precision > 0) {
-    formattedNumber += options.separator + parts[1];
-  }
-
-  if (negative) {
-    formattedNumber = "-" + formattedNumber;
-  }
-
-  if (options.strip_insignificant_zeros) {
-    var regex = {
-        separator: new RegExp(options.separator.replace(/\./, "\\.") + "$")
-      , zeros: /0+$/
-    };
+    options = this.prepareOptions(
+      options,
+      {precision: precision, format: "%n%u", delimiter: ""}
+    );
 
-    formattedNumber = formattedNumber
-      .replace(regex.zeros, "")
-      .replace(regex.separator, "")
+    number = this.toNumber(size, options);
+    number = options.format
+      .replace("%u", unit)
+      .replace("%n", number)
     ;
-  }
-
-  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.toHumanSize = function(number, options) {
-  var kb = 1024
-    , size = number
-    , iterations = 0
-    , unit
-    , precision
-  ;
-
-  while (size >= kb && iterations < 4) {
-    size = size / kb;
-    iterations += 1;
-  }
-
-  if (iterations === 0) {
-    unit = this.t("number.human.storage_units.units.byte", {count: size});
-    precision = 0;
-  } else {
-    unit = this.t("number.human.storage_units.units." + [null, "kb", "mb", "gb", "tb"][iterations]);
-    precision = (size - Math.floor(size) === 0) ? 0 : 1;
-  }
-
-  options = this.prepareOptions(
-    options,
-    {precision: precision, format: "%n%u", delimiter: ""}
-  );
-
-  number = this.toNumber(size, options);
-  number = options.format
-    .replace("%u", 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.pluralizer = function(locale) {
-  pluralizer = this.pluralizationRules[locale];
-  if (pluralizer !== undefined) return pluralizer;
-  return this.pluralizationRules["en"];
-};
-
-I18n.findAndTranslateValidNode = function(keys, translation) {
-  for (i = 0; i < keys.length; i++) {
-    key = keys[i];
-    if (this.isValidNode(translation, key)) return translation[key];
-  }
-  return null;
-};
-
-I18n.pluralize = function(count, scope, options) {
-  var translation;
-
-  try {
-    translation = this.lookup(scope, options);
-  } catch (error) {}
-
-  if (!translation) {
-    return this.missingTranslation(scope);
-  }
-
-  var message;
-  options = this.prepareOptions(options);
-  options.count = count.toString();
-
-  pluralizer = this.pluralizer(this.currentLocale());
-  key = pluralizer(Math.abs(count));
-  keys = ((typeof key == "object") && (key instanceof Array)) ? key : [key];
-
-  message = this.findAndTranslateValidNode(keys, translation);
-  if (message == null) message = this.missingTranslation(scope, keys[0]);
-
-  return this.interpolate(message, options);
-};
-
-I18n.missingTranslation = function() {
-  var message = '[missing "' + this.currentLocale()
-    , 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;
+
+    return number;
+  };
+
+  // Set aliases, so we can save some typing.
+  I18n.t = I18n.translate;
+  I18n.l = I18n.localize;
+  I18n.p = I18n.pluralize;
+})(I18n);
+
+if(!_.isUndefined(exports)){
+  module.exports = I18n;
+}