ember-rails-i18n 0.0.1

data/lib/javascripts/moment_locale/zh-tw.js

@@ -0,0 +1,84 @@
+// moment.js language configuration
+// language : traditional chinese (zh-tw)
+// author : Ben : https://github.com/ben-lin
+
+(function (factory) {
+    if (typeof define === 'function' && define.amd) {
+        define(['moment'], factory); // AMD
+    } else if (typeof exports === 'object') {
+        module.exports = factory(require('../moment')); // Node
+    } else {
+        factory(window.moment); // Browser global
+    }
+}(function (moment) {
+    return moment.lang('zh-tw', {
+        months : "一月_二月_三月_四月_五月_六月_七月_八月_九月_十月_十一月_十二月".split("_"),
+        monthsShort : "1月_2月_3月_4月_5月_6月_7月_8月_9月_10月_11月_12月".split("_"),
+        weekdays : "星期日_星期一_星期二_星期三_星期四_星期五_星期六".split("_"),
+        weekdaysShort : "週日_週一_週二_週三_週四_週五_週六".split("_"),
+        weekdaysMin : "日_一_二_三_四_五_六".split("_"),
+        longDateFormat : {
+            LT : "Ah點mm",
+            L : "YYYY年MMMD日",
+            LL : "YYYY年MMMD日",
+            LLL : "YYYY年MMMD日LT",
+            LLLL : "YYYY年MMMD日ddddLT",
+            l : "YYYY年MMMD日",
+            ll : "YYYY年MMMD日",
+            lll : "YYYY年MMMD日LT",
+            llll : "YYYY年MMMD日ddddLT"
+        },
+        meridiem : function (hour, minute, isLower) {
+            var hm = hour * 100 + minute;
+            if (hm < 900) {
+                return "早上";
+            } else if (hm < 1130) {
+                return "上午";
+            } else if (hm < 1230) {
+                return "中午";
+            } else if (hm < 1800) {
+                return "下午";
+            } else {
+                return "晚上";
+            }
+        },
+        calendar : {
+            sameDay : '[今天]LT',
+            nextDay : '[明天]LT',
+            nextWeek : '[下]ddddLT',
+            lastDay : '[昨天]LT',
+            lastWeek : '[上]ddddLT',
+            sameElse : 'L'
+        },
+        ordinal : function (number, period) {
+            switch (period) {
+            case "d" :
+            case "D" :
+            case "DDD" :
+                return number + "日";
+            case "M" :
+                return number + "月";
+            case "w" :
+            case "W" :
+                return number + "週";
+            default :
+                return number;
+            }
+        },
+        relativeTime : {
+            future : "%s內",
+            past : "%s前",
+            s : "幾秒",
+            m : "一分鐘",
+            mm : "%d分鐘",
+            h : "一小時",
+            hh : "%d小時",
+            d : "一天",
+            dd : "%d天",
+            M : "一個月",
+            MM : "%d個月",
+            y : "一年",
+            yy : "%d年"
+        }
+    });
+}));

data/vendor/assets/javascripts/locales/i18n.js

@@ -0,0 +1,598 @@
+/*global I18n:true */
+
+// https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/indexOf
+if (!Array.prototype.indexOf) {
+  Array.prototype.indexOf = function (searchElement, fromIndex) {
+    if ( this === undefined || this === null ) {
+      throw new TypeError( '"this" is null or not defined' );
+    }
+
+    var length = this.length >>> 0; // Hack to convert object.length to a UInt32
+
+    fromIndex = +fromIndex || 0;
+
+    if (Math.abs(fromIndex) === Infinity) {
+      fromIndex = 0;
+    }
+
+    if (fromIndex < 0) {
+      fromIndex += length;
+      if (fromIndex < 0) {
+        fromIndex = 0;
+      }
+    }
+
+    for (;fromIndex < length; fromIndex++) {
+      if (this[fromIndex] === searchElement) {
+        return fromIndex;
+      }
+    }
+
+    return -1;
+  };
+}
+
+// Instantiate the object
+var I18n = I18n || {};
+
+// Set default locale to english
+I18n.defaultLocale = "en";
+
+// Set default handling of translation fallbacks to false
+I18n.fallbacks = false;
+
+// Set default separator
+I18n.defaultSeparator = ".";
+
+// Set current locale to null
+I18n.locale = null;
+
+// Set the placeholder format. Accepts `{{placeholder}}` and `%{placeholder}`.
+I18n.PLACEHOLDER = /(?:\{\{|%\{)(.*?)(?:\}\}?)/gm;
+
+I18n.fallbackRules = {};
+
+I18n.pluralizationRules = {
+  en: function(n) {
+    return n === 0 ? ["zero", "none", "other"] : n === 1 ? "one" : "other";
+  },
+  "zh_CN": function(n) {
+    return n === 0 ? ["zero", "none", "other"] : "other";
+  },
+  "zh_TW": function(n) {
+    return n === 0 ? ["zero", "none", "other"] : "other";
+  }
+};
+
+I18n.getFallbacks = function(locale) {
+  if (locale === I18n.defaultLocale) {
+    return [];
+  } else if (!I18n.fallbackRules[locale]) {
+    var rules = [],
+        components = locale.split("-");
+
+    for (var l = 1; l < components.length; l++) {
+      rules.push(components.slice(0, l).join("-"));
+    }
+
+    rules.push(I18n.defaultLocale);
+
+    I18n.fallbackRules[locale] = rules;
+  }
+
+  return I18n.fallbackRules[locale];
+};
+
+I18n.isValidNode = function(obj, node, undefined) {
+  return obj[node] !== null && obj[node] !== undefined;
+};
+
+I18n.lookup = function(scope, options) {
+  options = options || {};
+  var lookupInitialScope = scope,
+      translations = this.prepareOptions(I18n.translations),
+      locale = options.locale || I18n.currentLocale(),
+      messages = translations[locale] || {},
+      currentScope;
+
+  options = this.prepareOptions(options);
+
+  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;
+        }
+      }
+    }
+
+    if (!messages && this.isValidNode(options, "defaultValue")) {
+        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 = {},
+      opts,
+      count = arguments.length;
+
+  for (var i = 0; i < count; i++) {
+    opts = arguments[i];
+
+    if (!opts) {
+      continue;
+    }
+
+    for (var key in opts) {
+      if (!this.isValidNode(options, key)) {
+        options[key] = opts[key];
+      }
+    }
+  }
+
+  return options;
+};
+
+I18n.interpolate = function(message, options) {
+  options = this.prepareOptions(options);
+  var matches = message.match(this.PLACEHOLDER),
+      placeholder,
+      value,
+      name;
+
+  if (!matches) {
+    return message;
+  }
+
+  for (var i = 0; placeholder = matches[i]; i++) {
+    name = placeholder.replace(this.PLACEHOLDER, "$1");
+
+    value = options[name];
+
+    if (!this.isValidNode(options, name)) {
+      value = "[missing " + placeholder + " value]";
+    }
+
+    var 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 (error) {
+    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(date) {
+  var matches, convertedDate;
+
+  // we have a date, so just return it.
+  if (typeof date === "object") {
+    return date;
+  }
+
+  // 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)?/);
+
+  if (matches) {
+    for (var i = 1; i <= 6; i++) {
+      matches[i] = parseInt(matches[i], 10) || 0;
+    }
+
+    // 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 {
+      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 {
+    // 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+$/
+    };
+
+    formattedNumber = formattedNumber
+      .replace(regex.zeros, "")
+      .replace(regex.separator, "")
+    ;
+  }
+
+  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) {
+  var pluralizer = this.pluralizationRules[locale];
+  if (pluralizer !== undefined) return pluralizer;
+  return this.pluralizationRules["en"];
+};
+
+I18n.findAndTranslateValidNode = function(keys, translation) {
+  for (var i = 0; i < keys.length; i++) {
+    var 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); }
+
+  options = this.prepareOptions(options);
+  options.count = count.toString();
+
+  var pluralizer = this.pluralizer(this.currentLocale());
+  var key = pluralizer(Math.abs(count));
+  var keys = ((typeof key === "object") && (key instanceof Array)) ? key : [key];
+
+  var message = this.findAndTranslateValidNode(keys, translation);
+  if (message == null) message = this.missingTranslation(scope, keys[0]);
+
+  return this.interpolate(message, options);
+};
+
+I18n.missingTranslation = function(scope, key) {
+  var message = '[' + this.currentLocale() + "." + scope;
+  if (key) { message += "." + key; }
+  return message + ']';
+};
+
+I18n.currentLocale = function() {
+  return (I18n.locale || I18n.defaultLocale);
+};
+
+// shortcuts
+I18n.t = I18n.translate;
+I18n.l = I18n.localize;
+I18n.p = I18n.pluralize;
+
+/**
+ Default format for storage units
+**/
+var oldI18ntoHumanSize = I18n.toHumanSize;
+I18n.toHumanSize = function(number, options) {
+  options = options || {};
+  options.format = I18n.t("number.human.storage_units.format");
+  return oldI18ntoHumanSize.apply(this, [number, options]);
+};
+
+/**
+ * Ember I18n helpers
+ */
+if (typeof(Ember) !== "undefined") {
+  I18n.normalizeHash = function(hash, hashTypes) {
+    for (var prop in hash) {
+      if (hashTypes[prop] === 'ID') {
+        hash[prop + 'Binding'] = hash[prop];
+        delete hash[prop];
+      }
+    }
+  };
+  
+  Ember.View.reopenClass({
+    registerHelper: function(helperName, helperClass) {
+      Ember.Handlebars.registerHelper(helperName, function(options) {
+        var hash = options.hash,
+            types = options.hashTypes;
+
+        I18n.normalizeHash(hash, types);
+        return Ember.Handlebars.helpers.view.call(this, helperClass, options);
+      });
+    },
+    
+    renderIfChanged: function() {
+      var args = Array.prototype.slice.call(arguments, 0);
+      args.unshift(function () { this.rerender(); });
+      return Ember.observer.apply(this, args);
+    }
+  });
+
+  /**
+    Look up a translation for an i18n key in our dictionary.
+
+    @method i18n
+    @for Handlebars
+  **/
+  Ember.Handlebars.registerHelper('i18n', function(property, options) {
+    // Resolve any properties
+    var params = options.hash,
+      self = this;
+
+    _.each(params, function(value, key) {
+      params[key] = Em.Handlebars.get(self, value, options);
+    });
+
+    return I18n.t(property, params);
+  });
+
+  /**
+   Bound version of i18n helper.
+   **/
+  Ember.Handlebars.registerBoundHelper("boundI18n", function(property, options) {
+    return new Handlebars.SafeString(I18n.t(property, options.hash));
+  });
+
+  /**
+    Set up an i18n binding that will update as a count changes, complete with pluralization.
+
+    @method countI18n
+    @for Handlebars
+  **/
+  Ember.Handlebars.registerHelper('countI18n', function(key, options) {
+    var view = Ember.View.extend({
+      tagName: 'span',
+      shouldRerender: Ember.View.renderIfChanged('count'),
+
+      render: function(buffer) {
+        buffer.push(I18n.t(key, { count: this.get('count') }));
+      }
+
+    });
+    return Ember.Handlebars.helpers.view.call(this, view, options);
+  });
+
+  if (Ember.EXTEND_PROTOTYPES) {
+    String.prototype.i18n = function(options) {
+      return I18n.t(String(this), options);
+    };
+  }
+}