walrus-rb 0.10.1.0

data/vendor/walrus.currencies.js

@@ -0,0 +1,57 @@
+(function() {
+  var Walrus, locale, separate;
+
+  Walrus = (typeof exports !== "undefined" && exports !== null ? require('./walrus') : this).Walrus;
+
+  separate = function(value, thousands, decimal) {
+    var fraction, whole, _ref;
+    _ref = value.split(decimal), whole = _ref[0], fraction = _ref[1];
+    whole = whole.replace(/(\d)(?=(\d{3})+$)/g, "$1" + thousands);
+    if (fraction) {
+      return [whole, fraction].join(decimal);
+    } else {
+      return whole;
+    }
+  };
+
+  /**
+   * *:currency*
+   * Returns a string formatted in the current locale's format.
+   * Delegates to [accounting.js](http://josscrowcroft.github.com/accounting.js/) if present.
+   *
+   * Parameters:
+   *  precision - the decimal place level to show cents, if applicable
+   *
+   * Usage:
+   *
+   *  {{ 36000 | :currency( '$', 2 ) }} // => $36,000.00
+   *  {{ 36000 | :currency }} // => $36,000
+  */
+
+  locale = Walrus.i18n.t('currencies');
+
+  if (typeof accounting !== "undefined" && accounting !== null) {
+    accounting.settings.currency.symbol = locale.symbol;
+    accounting.settings.currency.decimal = locale.decimal;
+    accounting.settings.currency.precision = locale.precision;
+    accounting.settings.currency.thousand = locale.thousand;
+    Walrus.addFilter('currency', function() {
+      return accounting.formatMoney.apply(accounting, arguments);
+    });
+    Walrus.addFilter('formatMoney', function() {
+      return accounting.formatMoney.apply(accounting, arguments);
+    });
+  } else {
+    Walrus.addFilter('currency', function(value, symbol, precision, decimal, thousand) {
+      var amount, moneys;
+      if (symbol == null) symbol = locale.symbol;
+      if (precision == null) precision = locale.precision;
+      if (decimal == null) decimal = locale.decimal;
+      if (thousand == null) thousand = locale.thousand;
+      moneys = value.toFixed(precision);
+      amount = separate(moneys, thousand, decimal);
+      return "" + symbol + amount;
+    });
+  }
+
+}).call(this);

data/vendor/walrus.dates.js

@@ -0,0 +1,296 @@
+(function() {
+  var Walrus;
+
+  Walrus = (typeof exports !== "undefined" && exports !== null ? require('./walrus') : this).Walrus;
+
+  /**
+   * *:strftime*
+   * Formats a date into the string given by `format`. Accepts any value
+   * that can be passed to `new Date( )`.
+   *
+   * Parameters:
+   *  format - The format string, according to these tokens, taken directly
+   *           from `man 3 strftime` (with some omissions):
+   *
+   *           %A    is replaced by national representation of the full weekday name.
+   *
+   *           %a    is replaced by national representation of the abbreviated weekday name.
+   *
+   *           %B    is replaced by national representation of the full month name.
+   *
+   *           %b    is replaced by national representation of the abbreviated month name.
+   *
+   *           %D    is equivalent to ``%m/%d/%y''.
+   *
+   *           %d    is replaced by the day of the month as a decimal number (01-31).
+   *
+   *           %e    is replaced by the day of month as a decimal number (1-31); single digits are
+   *                 preceded by a blank.
+   *
+   *           %F    is equivalent to ``%Y-%m-%d''.
+   *
+   *           %H    is replaced by the hour (24-hour clock) as a decimal number (00-23).
+   *
+   *           %I    is replaced by the hour (12-hour clock) as a decimal number (01-12).
+   *
+   *           %k    is replaced by the hour (24-hour clock) as a decimal number (0-23); single dig-
+   *                 its are preceded by a blank.
+   *
+   *           %l    is replaced by the hour (12-hour clock) as a decimal number (1-12); single dig-
+   *                 its are preceded by a blank.
+   *
+   *           %M    is replaced by the minute as a decimal number (00-59).
+   *
+   *           %m    is replaced by the month as a decimal number (01-12).
+   *
+   *           %n    is replaced by a newline.
+   *
+   *           %p    is replaced by national representation of either "ante meridiem" or "post meri-
+   *                 diem" as appropriate.
+   *
+   *           %R    is equivalent to ``%H:%M''.
+   *
+   *           %r    is equivalent to ``%I:%M:%S %p''.
+   *
+   *           %S    is replaced by the second as a decimal number (00-60).
+   *
+   *           %T    is equivalent to ``%H:%M:%S''.
+   *
+   *           %t    is replaced by a tab.
+   *
+   *           %U    is replaced by the week number of the year (Sunday as the first day of the
+   *                 week) as a decimal number (00-53).
+   *
+   *           %u    is replaced by the weekday (Monday as the first day of the week) as a decimal
+   *                 number (1-7).
+   *
+   *           %v    is equivalent to ``%e-%b-%Y''.
+   *
+   *           %w    is replaced by the weekday (Sunday as the first day of the week) as a decimal
+   *
+   *           %X    is replaced by national representation of the time.
+   *
+   *           %x    is replaced by national representation of the date.
+   *
+   *           %Y    is replaced by the year with century as a decimal number.
+   *
+   *           %y    is replaced by the year without century as a decimal number (00-99).
+   *
+   *           %Z    is replaced by the time zone name.
+  */
+
+  Walrus.addFilter('strftime', function(dateish, format) {
+    var date, pad,
+      _this = this;
+    date = new Date(dateish);
+    pad = function(value, to, padding) {
+      if (to == null) to = 2;
+      if (padding == null) padding = '0';
+      if (("" + value).length < to) {
+        return pad("" + padding + value, to, padding);
+      } else {
+        return value;
+      }
+    };
+    return format.replace(/%(.)/g, function(input) {
+      switch (input) {
+        case '%a':
+          return Walrus.i18n.t('dates.abbr_daynames')[date.getDay()];
+        case '%A':
+          return Walrus.i18n.t('dates.full_daynames')[date.getDay()];
+        case '%b':
+          return Walrus.i18n.t('dates.abbr_monthnames')[date.getMonth()];
+        case '%B':
+          return Walrus.i18n.t('dates.full_monthnames')[date.getMonth()];
+        case '%D':
+          return _this.strftime(date, '%m/%d/%y');
+        case '%d':
+          return pad(date.getDate());
+        case '%e':
+          return date.getDate();
+        case '%F':
+          return _this.strftime(date, '%Y-%m-%d');
+        case '%H':
+          return pad(date.getHours());
+        case '%I':
+          if (date.getHours() > 12) {
+            return pad(date.getHours() - 12);
+          } else {
+            return pad(date.getHours());
+          }
+          break;
+        case '%k':
+          return date.getHours();
+        case '%l':
+          if (date.getHours() > 12) {
+            return date.getHours() - 12;
+          } else {
+            return date.getHours();
+          }
+          break;
+        case '%M':
+          return pad(date.getMinutes());
+        case '%m':
+          return pad(date.getMonth() + 1);
+        case '%n':
+          return "\n";
+        case '%p':
+          if (date.getHours() > 12) {
+            return Walrus.i18n.t('dates.pm');
+          } else {
+            return Walrus.i18n.t('dates.am');
+          }
+          break;
+        case '%R':
+          return _this.strftime(date, '%H:%M');
+        case '%r':
+          return _this.strftime(date, '%I:%M:%S %p');
+        case '%S':
+          return pad(date.getSeconds());
+        case '%T':
+          return _this.strftime(date, '%H:%M:%S');
+        case '%t':
+          return "\t";
+        case '%u':
+          return date.getDay() || 7;
+        case '%v':
+          return _this.strftime(date, '%e-%b-%Y');
+        case '%w':
+          return date.getDay();
+        case '%X':
+          return date.toTimeString();
+        case '%x':
+          return date.toDateString();
+        case '%Y':
+          return date.getFullYear();
+        case '%y':
+          return date.getFullYear().toString().slice(-2);
+        case '%Z':
+          return date.toString().match(/\((\w+)\)/)[1] || '';
+      }
+    });
+  });
+
+  /**
+   * returns whether or not the given year is a leap year
+  */
+
+  Walrus.Utils.isLeapYear = function(year) {
+    return new Date(year, 1, 29).getDate() === 29;
+  };
+
+  /**
+   * returns the number of leap years between the two given years
+  */
+
+  Walrus.Utils.leapYearsBetween = function(from, to) {
+    var count, year;
+    if (from > to) return 0;
+    count = 0;
+    for (year = from; from <= to ? year <= to : year >= to; from <= to ? year++ : year--) {
+      if (this.isLeapYear(year)) count++;
+    }
+    return count;
+  };
+
+  /**
+   * returns the distance between two times in words
+  */
+
+  Walrus.Utils.distanceOfTimeInWords = function(ftime, ttime, includeSeconds) {
+    var d, diff, distanceInMinutes, distanceInSeconds, distanceInYears, fdate, fyear, leapYears, minuteOffsetForLeapYear, minutesWithOffset, remainder, t, tdate, tyear;
+    if (ttime == null) ttime = 0;
+    if (includeSeconds == null) includeSeconds = false;
+    t = function(keypath, count) {
+      var amount;
+      if (count == null) count = 1;
+      amount = count === 1 ? 'one' : 'other';
+      return Walrus.i18n.t("dates.distance_in_words." + keypath + "." + amount, {
+        count: count
+      });
+    };
+    fdate = new Date(ftime);
+    tdate = new Date(ttime);
+    diff = (tdate - fdate) / 1000;
+    distanceInMinutes = Math.round(Math.abs(diff) / 60);
+    distanceInSeconds = Math.round(Math.abs(diff));
+    d = function(divisor) {
+      if (divisor == null) divisor = 1;
+      return Math.round(distanceInMinutes / divisor);
+    };
+    switch (false) {
+      case !((0 <= distanceInMinutes && distanceInMinutes <= 1)):
+        if (!includeSeconds) {
+          if (distanceInMinutes === 0) {
+            return t('less_than_x_minutes');
+          } else {
+            return t('x_minutes');
+          }
+        } else {
+          switch (false) {
+            case !((0 <= distanceInSeconds && distanceInSeconds <= 4)):
+              return t('less_than_x_seconds', 5);
+            case !((5 <= distanceInSeconds && distanceInSeconds <= 9)):
+              return t('less_than_x_seconds', 10);
+            case !((10 <= distanceInSeconds && distanceInSeconds <= 19)):
+              return t('less_than_x_seconds', 20);
+            case !((20 <= distanceInSeconds && distanceInSeconds <= 39)):
+              return t('half_a_minute');
+            case !((40 <= distanceInSeconds && distanceInSeconds <= 59)):
+              return t('less_than_x_minutes');
+            default:
+              return "1 minute";
+          }
+        }
+        break;
+      case !((2 <= distanceInMinutes && distanceInMinutes <= 44)):
+        return t('x_minutes', d());
+      case !((45 <= distanceInMinutes && distanceInMinutes <= 89)):
+        return t('about_x_hours');
+      case !((90 <= distanceInMinutes && distanceInMinutes <= 1439)):
+        return t('about_x_hours', d(60));
+      case !((1440 <= distanceInMinutes && distanceInMinutes <= 2519)):
+        return t('x_days');
+      case !((2520 <= distanceInMinutes && distanceInMinutes <= 43199)):
+        return t('x_days', d(1440));
+      case !((43200 <= distanceInMinutes && distanceInMinutes <= 86399)):
+        return t('about_x_months');
+      case !((86400 <= distanceInMinutes && distanceInMinutes <= 525599)):
+        return t('x_months', d(43200));
+      default:
+        fyear = fdate.getFullYear();
+        if (fdate.getMonth() >= 2) fyear += 1;
+        tyear = tdate.getFullYear();
+        if (tdate.getMonth() < 2) tyear -= 1;
+        leapYears = Walrus.Utils.leapYearsBetween(fyear, tyear);
+        minuteOffsetForLeapYear = leapYears * 1440;
+        minutesWithOffset = distanceInMinutes - minuteOffsetForLeapYear;
+        remainder = minutesWithOffset % 525600;
+        distanceInYears = Math.floor(minutesWithOffset / 525600);
+        if (remainder < 131400) {
+          return t('about_x_years', distanceInYears);
+        } else if (remainder < 394200) {
+          return t('over_x_years', distanceInYears);
+        } else {
+          return t('almost_x_years', distanceInYears + 1);
+        }
+    }
+  };
+
+  /**
+   * *:time_ago_in_words*
+   * Returns a human-readable relative time phrase from the given date.
+   *
+   * Parameters:
+   *  includeSeconds - (Optional) whether or not to include results for less than one minute
+   *
+   * Usage:
+   *
+   *  {{ created_at | :time_ago_in_words( true ) }} // => "less than a minute"
+  */
+
+  Walrus.addFilter('time_ago_in_words', function(dateish, includeSeconds) {
+    return Walrus.Utils.distanceOfTimeInWords(dateish, new Date(), includeSeconds);
+  });
+
+}).call(this);

data/vendor/walrus.inflections.js

@@ -0,0 +1,120 @@
+(function() {
+  var Walrus, gsub, inflect, pluralize, plurals, singularize, singulars, uncountables,
+    __indexOf = Array.prototype.indexOf || function(item) { for (var i = 0, l = this.length; i < l; i++) { if (i in this && this[i] === item) return i; } return -1; };
+
+  Walrus = (typeof exports !== "undefined" && exports !== null ? require('./walrus') : this).Walrus;
+
+  /**
+   * Plenty of the methods in `walrus.inflections` are borrowed from or inspired by ActiveSupport:
+   * https://github.com/rails/rails/tree/master/activesupport
+   * JavaScript inflector implementation ported from underscore.inflection:
+   * https://github.com/jeremyruppel/underscore.inflection
+   * (Which was also inspired by and borrows from ActiveSupport)
+  */
+
+  plurals = [[/$/, 's'], [/s$/, 's'], [/(ax|test)is$/, '$1es'], [/(octop|vir)us$/, '$1i'], [/(octop|vir)i$/, '$1i'], [/(alias|status)$/, '$1es'], [/(bu)s$/, '$1ses'], [/(buffal|tomat)o$/, '$1oes'], [/([ti])um$/, '$1a'], [/([ti])a$/, '$1a'], [/sis$/, 'ses'], [/(?:([^f])fe|([lr])f)$/, '$1$2ves'], [/(hive)$/, '$1s'], [/([^aeiouy]|qu)y$/, '$1ies'], [/(x|ch|ss|sh)$/, '$1es'], [/(matr|vert|ind)(?:ix|ex)$/, '$1ices'], [/([m|l])ouse$/, '$1ice'], [/([m|l])ice$/, '$1ice'], [/^(ox)$/, '$1en'], [/^(oxen)$/, '$1'], [/(quiz)$/, '$1zes'], ['person', 'people'], ['man', 'men'], ['child', 'children'], ['sex', 'sexes'], ['move', 'moves'], ['cow', 'kine']].reverse();
+
+  singulars = [[/s$/, ''], [/(n)ews$/, '$1ews'], [/([ti])a$/, '$1um'], [/((a)naly|(b)a|(d)iagno|(p)arenthe|(p)rogno|(s)ynop|(t)he)ses$/, '$1$2sis'], [/(^analy)ses$/, '$1sis'], [/([^f])ves$/, '$1fe'], [/(hive)s$/, '$1'], [/(tive)s$/, '$1'], [/([lr])ves$/, '$1f'], [/([^aeiouy]|qu)ies$/, '$1y'], [/(s)eries$/, '$1eries'], [/(m)ovies$/, '$1ovie'], [/(x|ch|ss|sh)es$/, '$1'], [/([m|l])ice$/, '$1ouse'], [/(bus)es$/, '$1'], [/(o)es$/, '$1'], [/(shoe)s$/, '$1'], [/(cris|ax|test)es$/, '$1is'], [/(octop|vir)i$/, '$1us'], [/(alias|status)es$/, '$1'], [/^(ox)en/, '$1'], [/(vert|ind)ices$/, '$1ex'], [/(matr)ices$/, '$1ix'], [/(quiz)zes$/, '$1'], [/(database)s$/, '$1'], ['cow', 'kine'], ['move', 'moves'], ['sex', 'sexes'], ['child', 'children'], ['man', 'men'], ['person', 'people']].reverse();
+
+  uncountables = ['equipment', 'information', 'rice', 'money', 'species', 'series', 'fish', 'sheep', 'jeans'];
+
+  gsub = function(word, rule, replacement) {
+    var pattern;
+    pattern = new RegExp(rule.source || rule, 'gi');
+    if (pattern.test(word)) return word.replace(pattern, replacement);
+  };
+
+  inflect = function(word, rules) {
+    var result, rule, sub, _i, _len;
+    result = word;
+    for (_i = 0, _len = rules.length; _i < _len; _i++) {
+      rule = rules[_i];
+      sub = gsub(word, rule[0], rule[1]);
+      if (sub) result = sub;
+      if (sub) break;
+    }
+    return result;
+  };
+
+  singularize = function(word) {
+    if (__indexOf.call(uncountables, word) >= 0) return word;
+    return inflect(word, singulars);
+  };
+
+  pluralize = function(word, count, includeCount) {
+    var result;
+    if (includeCount == null) includeCount = false;
+    if (count != null) {
+      result = count === 1 ? singularize(word) : pluralize(word);
+      return result = includeCount ? "" + count + " " + result : result;
+    } else {
+      if (__indexOf.call(uncountables, word) >= 0) return word;
+      return inflect(word, plurals);
+    }
+  };
+
+  /**
+   * *:pluralize*
+   * Pluralizes the given word, optionally based on a _count_, and also optionally
+   * including the count in the result.
+   *
+   * Parameters:
+   *  word - the word to be pluralized
+   *  count - Optional: count to base pluralization on
+   *  includeCount - Optional: whether or not to include the count in the result
+   *
+   * Usage:
+   *
+   *  {{ "book" | :pluralize }} // => "books"
+   *
+   *  {{ "book" | :pluralize( 1 ) }} // => "book"
+   *
+   *  {{ "book" | :pluralize( 5, true ) }} // => "5 books"
+  */
+
+  Walrus.addFilter('pluralize', pluralize);
+
+  /**
+   * *:singularize*
+   * Singularizes the given word. You're probably looking for `pluralize`.
+   *
+   * Parameters: none
+   *
+   * Usage:
+   *
+   *  {{ "books" | :singularize }} // => "book"
+  */
+
+  Walrus.addFilter('singularize', singularize);
+
+  /**
+   * *:ordinalize*
+   * Turns a number into an ordinal string, like 1st, 2nd, 3rd, etc...
+   *
+   * Parameters: none
+   *
+   * Usage:
+   *
+   *  {{ 5 | :ordinalize }} // => "5th"
+  */
+
+  Walrus.addFilter('ordinalize', function(value) {
+    var normal, _ref;
+    normal = Math.abs(Math.round(value));
+    if (_ref = normal % 100, __indexOf.call([11, 12, 13], _ref) >= 0) {
+      return "" + value + "th";
+    } else {
+      switch (normal % 10) {
+        case 1:
+          return "" + value + "st";
+        case 2:
+          return "" + value + "nd";
+        case 3:
+          return "" + value + "rd";
+        default:
+          return "" + value + "th";
+      }
+    }
+  });
+
+}).call(this);