rearview 1.0.0.rc1-jruby → 1.0.0.rc2-jruby

data/public/rearview-src/vendor/xdate/js/xdate.js

@@ -0,0 +1,802 @@
+/**
+ * @preserve XDate v0.7
+ * Docs & Licensing: http://arshaw.com/xdate/
+ */
+
+/*
+ * Internal Architecture
+ * ---------------------
+ * An XDate wraps a native Date. The native Date is stored in the '0' property of the object.
+ * UTC-mode is determined by whether the internal native Date's toString method is set to
+ * Date.prototype.toUTCString (see getUTCMode).
+ *
+ */
+
+var XDate = (function(Date, Math, Array, undefined) {
+
+
+/** @const */ var FULLYEAR     = 0;
+/** @const */ var MONTH        = 1;
+/** @const */ var DATE         = 2;
+/** @const */ var HOURS        = 3;
+/** @const */ var MINUTES      = 4;
+/** @const */ var SECONDS      = 5;
+/** @const */ var MILLISECONDS = 6;
+/** @const */ var DAY          = 7;
+/** @const */ var YEAR         = 8;
+/** @const */ var WEEK         = 9;
+/** @const */ var DAY_MS = 86400000;
+var ISO_FORMAT_STRING = "yyyy-MM-dd'T'HH:mm:ss(.fff)";
+var ISO_FORMAT_STRING_TZ = ISO_FORMAT_STRING + "zzz";
+
+
+var methodSubjects = [
+    'FullYear',     // 0
+    'Month',        // 1
+    'Date',         // 2
+    'Hours',        // 3
+    'Minutes',      // 4
+    'Seconds',      // 5
+    'Milliseconds', // 6
+    'Day',          // 7
+    'Year'          // 8
+];
+var subjectPlurals = [
+    'Years',        // 0
+    'Months',       // 1
+    'Days'          // 2
+];
+var unitsWithin = [
+    12,   // months in year
+    31,   // days in month (sort of)
+    24,   // hours in day
+    60,   // minutes in hour
+    60,   // seconds in minute
+    1000, // milliseconds in second
+    1     //
+];
+var formatStringRE = new RegExp(
+    "(([a-zA-Z])\\2*)|" + // 1, 2
+    "(\\(" + "(('.*?'|\\(.*?\\)|.)*?)" + "\\))|" + // 3, 4, 5 (allows for 1 level of inner quotes or parens)
+    "('(.*?)')" // 6, 7
+);
+var UTC = Date.UTC;
+var toUTCString = Date.prototype.toUTCString;
+var proto = XDate.prototype;
+
+
+
+// This makes an XDate look pretty in Firebug and Web Inspector.
+// It makes an XDate seem array-like, and displays [ <internal-date>.toString() ]
+proto.length = 1;
+proto.splice = Array.prototype.splice;
+
+
+
+
+/* Constructor
+---------------------------------------------------------------------------------*/
+
+
+function XDate() {
+    return init(
+        (this instanceof XDate) ? this : new XDate(),
+        arguments
+    );
+}
+
+
+function init(xdate, args) {
+    var len = args.length;
+    var utcMode;
+    if (isBoolean(args[len-1])) {
+        utcMode = args[--len];
+        args = slice(args, 0, len);
+    }
+    if (!len) {
+        xdate[0] = new Date();
+    }
+    else if (len == 1) {
+        var arg = args[0];
+        if (arg instanceof Date || isNumber(arg)) {
+            xdate[0] = new Date(+arg);
+        }
+        else if (arg instanceof XDate) {
+            xdate[0] = _clone(arg);
+        }
+        else if (isString(arg)) {
+            xdate[0] = new Date(0);
+            xdate = parse(arg, utcMode || false, xdate);
+        }
+    }
+    else {
+        xdate[0] = new Date(UTC.apply(Date, args));
+        if (!utcMode) {
+            xdate[0] = coerceToLocal(xdate[0]);
+        }
+    }
+    if (isBoolean(utcMode)) {
+        setUTCMode(xdate, utcMode);
+    }
+    return xdate;
+}
+
+
+
+/* UTC Mode Methods
+---------------------------------------------------------------------------------*/
+
+
+proto.getUTCMode = methodize(getUTCMode);
+function getUTCMode(xdate) {
+    return xdate[0].toString === toUTCString;
+};
+
+
+proto.setUTCMode = methodize(setUTCMode);
+function setUTCMode(xdate, utcMode, doCoercion) {
+    if (utcMode) {
+        if (!getUTCMode(xdate)) {
+            if (doCoercion) {
+                xdate[0] = coerceToUTC(xdate[0]);
+            }
+            xdate[0].toString = toUTCString;
+        }
+    }else{
+        if (getUTCMode(xdate)) {
+            if (doCoercion) {
+                xdate[0] = coerceToLocal(xdate[0]);
+            }else{
+                xdate[0] = new Date(+xdate[0]);
+            }
+            // toString will have been cleared
+        }
+    }
+    return xdate; // for chaining
+}
+
+
+proto.getTimezoneOffset = function() {
+    if (getUTCMode(this)) {
+        return 0;
+    }else{
+        return this[0].getTimezoneOffset();
+    }
+};
+
+
+
+/* get / set / add / diff Methods (except for week-related)
+---------------------------------------------------------------------------------*/
+
+
+each(methodSubjects, function(subject, fieldIndex) {
+
+    proto['get' + subject] = function() {
+        return _getField(this[0], getUTCMode(this), fieldIndex);
+    };
+    
+    if (fieldIndex != YEAR) { // because there is no getUTCYear
+    
+        proto['getUTC' + subject] = function() {
+            return _getField(this[0], true, fieldIndex);
+        };
+        
+    }
+
+    if (fieldIndex != DAY) { // because there is no setDay or setUTCDay
+                             // and the add* and diff* methods use DATE instead
+        
+        proto['set' + subject] = function(value) {
+            _set(this, fieldIndex, value, arguments, getUTCMode(this));
+            return this; // for chaining
+        };
+        
+        if (fieldIndex != YEAR) { // because there is no setUTCYear
+                                  // and the add* and diff* methods use FULLYEAR instead
+            
+            proto['setUTC' + subject] = function(value) {
+                _set(this, fieldIndex, value, arguments, true);
+                return this; // for chaining
+            };
+            
+            proto['add' + (subjectPlurals[fieldIndex] || subject)] = function(delta, preventOverflow) {
+                _add(this, fieldIndex, delta, preventOverflow);
+                return this; // for chaining
+            };
+            
+            proto['diff' + (subjectPlurals[fieldIndex] || subject)] = function(otherDate) {
+                return _diff(this, otherDate, fieldIndex);
+            };
+            
+        }
+        
+    }
+
+});
+
+
+function _set(xdate, fieldIndex, value, args, useUTC) {
+    var getField = curry(_getField, xdate[0], useUTC);
+    var setField = curry(_setField, xdate[0], useUTC);
+    var month = fieldIndex == MONTH ? value % 12 : getField(MONTH);
+    var preventOverflow = false;
+    if (args.length == 2 && isBoolean(args[1])) {
+        preventOverflow = args[1];
+        args = [value];
+    }
+    setField(fieldIndex, args);
+    if (preventOverflow && getField(MONTH) != month) {
+        setField(MONTH, [ getField(MONTH) - 1 ]);
+        setField(DATE, [ getDaysInMonth(getField(FULLYEAR), getField(MONTH)) ]);
+    }
+}
+
+
+function _add(xdate, fieldIndex, delta, preventOverflow) {
+    delta = Number(delta);
+    var intDelta = Math.floor(delta);
+    xdate['set' + methodSubjects[fieldIndex]](
+        xdate['get' + methodSubjects[fieldIndex]]() + intDelta,
+        preventOverflow || false
+    );
+    if (intDelta != delta && fieldIndex < MILLISECONDS) {
+        _add(xdate, fieldIndex+1, (delta-intDelta)*unitsWithin[fieldIndex], preventOverflow);
+    }
+}
+
+
+function _diff(xdate1, xdate2, fieldIndex) { // fieldIndex=FULLYEAR is for years, fieldIndex=DATE is for days
+    xdate1 = xdate1.clone().setUTCMode(true, true);
+    xdate2 = XDate(xdate2).setUTCMode(true, true);
+    var v = 0;
+    if (fieldIndex == FULLYEAR || fieldIndex == MONTH) {
+        for (var i=MILLISECONDS, methodName; i>=fieldIndex; i--) {
+            v /= unitsWithin[i];
+            v += _getField(xdate2, false, i) - _getField(xdate1, false, i);
+        }
+        if (fieldIndex == MONTH) {
+            v += (xdate2.getFullYear() - xdate1.getFullYear()) * 12;
+        }
+    }
+    else if (fieldIndex == DATE) {
+        var clear1 = xdate1.toDate().setUTCHours(0, 0, 0, 0); // returns an ms value
+        var clear2 = xdate2.toDate().setUTCHours(0, 0, 0, 0); // returns an ms value
+        v = Math.round((clear2 - clear1) / DAY_MS) + ((xdate2 - clear2) - (xdate1 - clear1)) / DAY_MS;
+    }
+    else {
+        v = (xdate2 - xdate1) / [
+            3600000, // milliseconds in hour
+            60000,   // milliseconds in minute
+            1000,    // milliseconds in second
+            1        //
+            ][fieldIndex - 3];
+    }
+    return v;
+}
+
+
+
+/* Week Methods
+---------------------------------------------------------------------------------*/
+
+
+proto.getWeek = function() {
+    return _getWeek(curry(_getField, this, false));
+};
+
+
+proto.getUTCWeek = function() {
+    return _getWeek(curry(_getField, this, true));
+};
+
+
+proto.setWeek = function(n, year) {
+    _setWeek(this, n, year, false);
+    return this; // for chaining
+};
+
+
+proto.setUTCWeek = function(n, year) {
+    _setWeek(this, n, year, true);
+    return this; // for chaining
+};
+
+
+proto.addWeeks = function(delta) {
+    return this.addDays(Number(delta) * 7);
+};
+
+
+proto.diffWeeks = function(otherDate) {
+    return _diff(this, otherDate, DATE) / 7;
+};
+
+
+function _getWeek(getField) {
+    return getWeek(getField(FULLYEAR), getField(MONTH), getField(DATE));
+}
+
+
+function getWeek(year, month, date) {
+    var d = new Date(UTC(year, month, date));
+    var currentWeek1 = getWeek1(year);
+    var week1 = currentWeek1;
+    if (d < currentWeek1) {
+        week1 = getWeek1(year-1);
+    }else{
+        var nextWeek1 = getWeek1(year+1);
+        if (d >= nextWeek1) {
+            week1 = nextWeek1;
+        }
+    }
+    return Math.floor(Math.round((d - week1) / DAY_MS) / 7) + 1;
+}
+
+
+function getWeek1(year) { // returns Date of first week of year, in UTC
+    var d = new Date(UTC(year, 0, 4));
+    d.setUTCDate(d.getUTCDate() - (d.getUTCDay() + 6) % 7); // make it Monday of the week
+    return d;
+}
+
+
+function _setWeek(xdate, n, year, useUTC) {
+    var getField = curry(_getField, xdate, useUTC);
+    var setField = curry(_setField, xdate, useUTC);
+    var d = getWeek1(year===undefined ? getField(FULLYEAR) : year);
+    if (!useUTC) {
+        d = coerceToLocal(d);
+    }
+    xdate.setTime(+d);
+    setField(DATE, [ getField(DATE) + (n-1) * 7 ]); // would have used xdate.addUTCWeeks :(
+        // n-1 because n is 1-based
+}
+
+
+
+/* Parsing
+---------------------------------------------------------------------------------*/
+
+
+XDate.parsers = [
+    parseISO
+];
+
+
+XDate.parse = function(str) {
+    return +XDate(''+str);
+};
+
+
+function parse(str, utcMode, xdate) {
+    var parsers = XDate.parsers;
+    var i = 0;
+    var res;
+    for (; i<parsers.length; i++) {
+        res = parsers[i](str, utcMode, xdate);
+        if (res) {
+            return res;
+        }
+    }
+    xdate[0] = new Date(str);
+    return xdate;
+}
+
+
+function parseISO(str, utcMode, xdate) {
+    var m = str.match(/^(\d{4})(-(\d{2})(-(\d{2})([T ](\d{2}):(\d{2})(:(\d{2})(\.(\d+))?)?(Z|(([-+])(\d{2})(:?(\d{2}))?))?)?)?)?$/);
+    if (m) {
+        var d = new Date(UTC(
+            m[1],
+            m[3] ? m[3] - 1 : 0,
+            m[5] || 1,
+            m[7] || 0,
+            m[8] || 0,
+            m[10] || 0,
+            m[12] ? Number('0.' + m[12]) * 1000 : 0
+        ));
+        if (m[13]) { // has gmt offset or Z
+            if (m[14]) { // has gmt offset
+                d.setUTCMinutes(
+                    d.getUTCMinutes() +
+                    (m[15] == '-' ? 1 : -1) * (Number(m[16]) * 60 + (m[18] ? Number(m[18]) : 0))
+                );
+            }
+        }else{ // no specified timezone
+            if (!utcMode) {
+                d = coerceToLocal(d);
+            }
+        }
+        return xdate.setTime(+d);
+    }
+}
+
+
+
+/* Formatting
+---------------------------------------------------------------------------------*/
+
+
+proto.toString = function(formatString, settings, uniqueness) {
+    if (formatString === undefined || !valid(this)) {
+        return this[0].toString(); // already accounts for utc-mode (might be toUTCString)
+    }else{
+        return format(this, formatString, settings, uniqueness, getUTCMode(this));
+    }
+};
+
+
+proto.toUTCString = proto.toGMTString = function(formatString, settings, uniqueness) {
+    if (formatString === undefined || !valid(this)) {
+        return this[0].toUTCString();
+    }else{
+        return format(this, formatString, settings, uniqueness, true);
+    }
+};
+
+
+proto.toISOString = function() {
+    return this.toUTCString(ISO_FORMAT_STRING_TZ);
+};
+
+
+XDate.defaultLocale = '';
+XDate.locales = {
+    '': {
+        monthNames: ['January','February','March','April','May','June','July','August','September','October','November','December'],
+        monthNamesShort: ['Jan','Feb','Mar','Apr','May','Jun','Jul','Aug','Sep','Oct','Nov','Dec'],
+        dayNames: ['Sunday','Monday','Tuesday','Wednesday','Thursday','Friday','Saturday'],
+        dayNamesShort: ['Sun','Mon','Tue','Wed','Thu','Fri','Sat'],
+        amDesignator: 'AM',
+        pmDesignator: 'PM'
+    }
+};
+XDate.formatters = {
+    i: ISO_FORMAT_STRING,
+    u: ISO_FORMAT_STRING_TZ
+};
+
+
+function format(xdate, formatString, settings, uniqueness, useUTC) {
+
+    var locales = XDate.locales;
+    var defaultLocaleSettings = locales[XDate.defaultLocale] || {};
+    var getField = curry(_getField, xdate, useUTC);
+    
+    settings = (isString(settings) ? locales[settings] : settings) || {};
+    
+    function getSetting(name) {
+        return settings[name] || defaultLocaleSettings[name];
+    }
+    
+    function getFieldAndTrace(fieldIndex) {
+        if (uniqueness) {
+            var i = (fieldIndex == DAY ? DATE : fieldIndex) - 1;
+            for (; i>=0; i--) {
+                uniqueness.push(getField(i));
+            }
+        }
+        return getField(fieldIndex);
+    }
+    
+    return _format(xdate, formatString, getFieldAndTrace, getSetting, useUTC);
+}
+
+
+function _format(xdate, formatString, getField, getSetting, useUTC) {
+    var m;
+    var subout;
+    var out = '';
+    while (m = formatString.match(formatStringRE)) {
+        out += formatString.substr(0, m.index);
+        if (m[1]) { // consecutive alphabetic characters
+            out += processTokenString(xdate, m[1], getField, getSetting, useUTC);
+        }
+        else if (m[3]) { // parenthesis
+            subout = _format(xdate, m[4], getField, getSetting, useUTC);
+            if (parseInt(subout.replace(/\D/g, ''), 10)) { // if any of the numbers are non-zero. or no numbers at all
+                out += subout;
+            }
+        }
+        else { // else if (m[6]) { // single quotes
+            out += m[7] || "'"; // if inner is blank, meaning 2 consecutive quotes = literal single quote
+        }
+        formatString = formatString.substr(m.index + m[0].length);
+    }
+    return out + formatString;
+}
+
+
+function processTokenString(xdate, tokenString, getField, getSetting, useUTC) {
+    var end = tokenString.length;
+    var replacement;
+    var out = '';
+    while (end > 0) {
+        replacement = getTokenReplacement(xdate, tokenString.substr(0, end), getField, getSetting, useUTC);
+        if (replacement !== undefined) {
+            out += replacement;
+            tokenString = tokenString.substr(end);
+            end = tokenString.length;
+        }else{
+            end--;
+        }
+    }
+    return out + tokenString;
+}
+
+
+function getTokenReplacement(xdate, token, getField, getSetting, useUTC) {
+    var formatter = XDate.formatters[token];
+    if (isString(formatter)) {
+        return _format(xdate, formatter, getField, getSetting, useUTC);
+    }
+    else if (isFunction(formatter)) {
+        return formatter(xdate, useUTC || false, getSetting);
+    }
+    switch (token) {
+        case 'fff'  : return zeroPad(getField(MILLISECONDS), 3);
+        case 's'    : return getField(SECONDS);
+        case 'ss'   : return zeroPad(getField(SECONDS));
+        case 'm'    : return getField(MINUTES);
+        case 'mm'   : return zeroPad(getField(MINUTES));
+        case 'h'    : return getField(HOURS) % 12 || 12;
+        case 'hh'   : return zeroPad(getField(HOURS) % 12 || 12);
+        case 'H'    : return getField(HOURS);
+        case 'HH'   : return zeroPad(getField(HOURS));
+        case 'd'    : return getField(DATE);
+        case 'dd'   : return zeroPad(getField(DATE));
+        case 'ddd'  : return getSetting('dayNamesShort')[getField(DAY)] || '';
+        case 'dddd' : return getSetting('dayNames')[getField(DAY)] || '';
+        case 'M'    : return getField(MONTH) + 1;
+        case 'MM'   : return zeroPad(getField(MONTH) + 1);
+        case 'MMM'  : return getSetting('monthNamesShort')[getField(MONTH)] || '';
+        case 'MMMM' : return getSetting('monthNames')[getField(MONTH)] || '';
+        case 'yy'   : return (getField(FULLYEAR)+'').substring(2);
+        case 'yyyy' : return getField(FULLYEAR);
+        case 't'    : return _getDesignator(getField, getSetting).substr(0, 1).toLowerCase();
+        case 'tt'   : return _getDesignator(getField, getSetting).toLowerCase();
+        case 'T'    : return _getDesignator(getField, getSetting).substr(0, 1);
+        case 'TT'   : return _getDesignator(getField, getSetting);
+        case 'z'    :
+        case 'zz'   :
+        case 'zzz'  : return useUTC ? 'Z' : _getTZString(xdate, token);
+        case 'w'    : return _getWeek(getField);
+        case 'ww'   : return zeroPad(_getWeek(getField));
+        case 'S'    :
+            var d = getField(DATE);
+            if (d > 10 && d < 20) return 'th';
+            return ['st', 'nd', 'rd'][d % 10 - 1] || 'th';
+    }
+}
+
+
+function _getTZString(xdate, token) {
+    var tzo = xdate.getTimezoneOffset();
+    var sign = tzo < 0 ? '+' : '-';
+    var hours = Math.floor(Math.abs(tzo) / 60);
+    var minutes = Math.abs(tzo) % 60;
+    var out = hours;
+    if (token == 'zz') {
+        out = zeroPad(hours);
+    }
+    else if (token == 'zzz') {
+        out = zeroPad(hours) + ':' + zeroPad(minutes);
+    }
+    return sign + out;
+}
+
+
+function _getDesignator(getField, getSetting) {
+    return getField(HOURS) < 12 ? getSetting('amDesignator') : getSetting('pmDesignator');
+}
+
+
+
+/* Misc Methods
+---------------------------------------------------------------------------------*/
+
+
+each(
+    [ // other getters
+        'getTime',
+        'valueOf',
+        'toDateString',
+        'toTimeString',
+        'toLocaleString',
+        'toLocaleDateString',
+        'toLocaleTimeString',
+        'toJSON'
+    ],
+    function(methodName) {
+        proto[methodName] = function() {
+            return this[0][methodName]();
+        };
+    }
+);
+
+
+proto.setTime = function(t) {
+    this[0].setTime(t);
+    return this; // for chaining
+};
+
+
+proto.valid = methodize(valid);
+function valid(xdate) {
+    return !isNaN(+xdate[0]);
+}
+
+
+proto.clone = function() {
+    return new XDate(this);
+};
+
+
+proto.clearTime = function() {
+    return this.setHours(0, 0, 0, 0); // will return an XDate for chaining
+};
+
+
+proto.toDate = function() {
+    return new Date(+this[0]);
+};
+
+
+
+/* Misc Class Methods
+---------------------------------------------------------------------------------*/
+
+
+XDate.now = function() {
+    return +new Date();
+};
+
+
+XDate.today = function() {
+    return new XDate().clearTime();
+};
+
+
+XDate.UTC = UTC;
+
+
+XDate.getDaysInMonth = getDaysInMonth;
+
+
+
+/* Internal Utilities
+---------------------------------------------------------------------------------*/
+
+
+function _clone(xdate) { // returns the internal Date object that should be used
+    var d = new Date(+xdate[0]);
+    if (getUTCMode(xdate)) {
+        d.toString = toUTCString;
+    }
+    return d;
+}
+
+
+function _getField(d, useUTC, fieldIndex) {
+    return d['get' + (useUTC ? 'UTC' : '') + methodSubjects[fieldIndex]]();
+}
+
+
+function _setField(d, useUTC, fieldIndex, args) {
+    d['set' + (useUTC ? 'UTC' : '') + methodSubjects[fieldIndex]].apply(d, args);
+}
+
+
+
+/* Date Math Utilities
+---------------------------------------------------------------------------------*/
+
+
+function coerceToUTC(date) {
+    return new Date(UTC(
+        date.getFullYear(),
+        date.getMonth(),
+        date.getDate(),
+        date.getHours(),
+        date.getMinutes(),
+        date.getSeconds(),
+        date.getMilliseconds()
+    ));
+}
+
+
+function coerceToLocal(date) {
+    return new Date(
+        date.getUTCFullYear(),
+        date.getUTCMonth(),
+        date.getUTCDate(),
+        date.getUTCHours(),
+        date.getUTCMinutes(),
+        date.getUTCSeconds(),
+        date.getUTCMilliseconds()
+    );
+}
+
+
+function getDaysInMonth(year, month) {
+    return 32 - new Date(UTC(year, month, 32)).getUTCDate();
+}
+
+
+
+/* General Utilities
+---------------------------------------------------------------------------------*/
+
+
+function methodize(f) {
+    return function() {
+        return f.apply(undefined, [this].concat(slice(arguments)));
+    };
+}
+
+
+function curry(f) {
+    var firstArgs = slice(arguments, 1);
+    return function() {
+        return f.apply(undefined, firstArgs.concat(slice(arguments)));
+    };
+}
+
+
+function slice(a, start, end) {
+    return Array.prototype.slice.call(
+        a,
+        start || 0, // start and end cannot be undefined for IE
+        end===undefined ? a.length : end
+    );
+}
+
+
+function each(a, f) {
+    for (var i=0; i<a.length; i++) {
+        f(a[i], i);
+    };
+}
+
+
+function isString(arg) {
+    return typeof arg == 'string';
+}
+
+
+function isNumber(arg) {
+    return typeof arg == 'number';
+}
+
+
+function isBoolean(arg) {
+    return typeof arg == 'boolean';
+}
+
+
+function isFunction(arg) {
+    return typeof arg == 'function';
+}
+
+
+function zeroPad(n, len) {
+    len = len || 2;
+    n += '';
+    while (n.length < len) {
+        n = '0' + n;
+    }
+    return n;
+}
+
+
+
+// Export for Node.js
+if (typeof module !== 'undefined' && module.exports) {
+    module.exports = XDate;
+}
+
+
+return XDate;
+
+})(Date, Math, Array);