Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with HTTPS or Subversion.

Download ZIP
Browse files

initial import of Cromag.js

  • Loading branch information...
commit d0ad340954071e38671fa3335a67d7b41eea7067 0 parents
@JerrySievert JerrySievert authored
776 cromag.js
@@ -0,0 +1,776 @@
+/*
+
+© 2011 by Jerry Sievert
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+*/
+
+(function () {
+ // constants
+ var monthsAbbr = [
+ 'Jan',
+ 'Feb',
+ 'Mar',
+ 'Apr',
+ 'May',
+ 'Jun',
+ 'Jul',
+ 'Aug',
+ 'Sep',
+ 'Oct',
+ 'Nov',
+ 'Dec'
+ ];
+
+ var monthsFull = [
+ 'January',
+ 'February',
+ 'March',
+ 'April',
+ 'May',
+ 'June',
+ 'July',
+ 'August',
+ 'September',
+ 'October',
+ 'November',
+ 'December'
+ ];
+
+ var dayNames = {
+ 'su': 0,
+ 'sun': 0,
+ 'sunday': 0,
+ 'mo': 1,
+ 'mon': 1,
+ 'monday': 1,
+ 'tu': 2,
+ 'tue': 2,
+ 'tuesday': 2,
+ 'we': 3,
+ 'wed': 3,
+ 'wednesday': 3,
+ 'th': 4,
+ 'thu': 4,
+ 'thursday': 4,
+ 'fr': 5,
+ 'fri': 5,
+ 'friday': 5,
+ 'sa': 6,
+ 'sat': 6,
+ 'saturday': 6
+ };
+ var monthsAll = monthsFull.concat(monthsAbbr);
+ var daysAll = [
+ 'su',
+ 'sun',
+ 'sunday',
+ 'mo',
+ 'mon',
+ 'monday',
+ 'tu',
+ 'tue',
+ 'tuesday',
+ 'we',
+ 'wed',
+ 'wednesday',
+ 'th',
+ 'thu',
+ 'thursday',
+ 'fr',
+ 'fri',
+ 'friday',
+ 'sa',
+ 'sat',
+ 'saturday'
+ ];
+
+ var monthNames = {
+ 'jan': 0,
+ 'january': 0,
+ 'feb': 1,
+ 'february': 1,
+ 'mar': 2,
+ 'march': 2,
+ 'apr': 3,
+ 'april': 3,
+ 'may': 4,
+ 'jun': 5,
+ 'june': 5,
+ 'jul': 6,
+ 'july': 6,
+ 'aug': 7,
+ 'august': 7,
+ 'sep': 8,
+ 'september': 8,
+ 'oct': 9,
+ 'october': 9,
+ 'nov': 10,
+ 'november': 10,
+ 'dec': 11,
+ 'december': 11
+ };
+
+ var daysInMonth = [ 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 ];
+
+
+ // private helper functions
+ /** @ignore */
+ function pad(str, length) {
+ str = String(str);
+ while (str.length < length) {
+ str = '0' + str;
+ }
+ return str;
+ }
+
+ var isInteger = function (str) {
+ if (str.match(/^(\d+)$/)) {
+ return true;
+ }
+ return false;
+ };
+ var getInt = function (str, i, minlength, maxlength) {
+ for (var x = maxlength; x >= minlength; x--) {
+ var token = str.substring(i, i + x);
+ if (token.length < minlength) {
+ return null;
+ }
+ if (isInteger(token)) {
+ return token;
+ }
+ }
+ return null;
+ };
+
+ var Cromag = function () {
+ var args = Array.prototype.slice.call(arguments);
+
+ // this is horrible. there has to be a better way for this, dealing
+ // with the Date object is painful at best due to its "special"
+ // constrainsts
+ if (args.length === 1) {
+ this.date = new Date(args[0]);
+ } else if (args.length === 3) {
+ this.date = new Date(args[0], args[1], args[2]);
+ } else if (args.length === 4) {
+ this.date = new Date(args[0], args[1], args[2], args[3]);
+ } else if (args.length === 5) {
+ this.date = new Date(args[0], args[1], args[2], args[3], args[4]);
+ } else if (args.length === 6) {
+ this.date = new Date(args[0], args[1], args[2], args[3], args[4], args[5]);
+ } else if (args.length === 7) {
+ this.date = new Date(args[0], args[1], args[2], args[3], args[4], args[5], args[6]);
+ } else {
+ this.date = new Date();
+ }
+ };
+
+
+ // static class methods
+ Cromag.now = Date.now;
+
+ Cromag.UTC = Date.UTC;
+
+ // ------------------------------------------------------------------
+ // getDateFromFormat( date_string , format_string )
+ //
+ // This function takes a date string and a format string. It matches
+ // If the date string matches the format string, it returns the
+ // getTime() of the date. If it does not match, it returns NaN.
+ // Original Author: Matt Kruse <matt@mattkruse.com>
+ // WWW: http://www.mattkruse.com/
+ // Adapted from: http://www.mattkruse.com/javascript/date/source.html
+ // ------------------------------------------------------------------
+
+
+ var getDateFromFormat = function (val, format) {
+ val = val + "";
+ format = format + "";
+ var iVal = 0;
+ var iFormat = 0;
+ var c = "";
+ var token = "";
+ var token2 = "";
+ var x, y;
+ var now = new Cromag();
+ var year = now.getYear();
+ var month = now.getMonth() + 1;
+ var date = 1;
+ var hh = 0;
+ var mm = 0;
+ var ss = 0;
+ var ampm = "";
+
+
+
+ while (iFormat < format.length) {
+ // Get next token from format string
+ c = format.charAt(iFormat);
+ token = "";
+ while ((format.charAt(iFormat) === c) && (iFormat < format.length)) {
+ token += format.charAt(iFormat++);
+ }
+ // Extract contents of value based on format token
+ if (token === "yyyy" || token === "yy" || token === "y") {
+ if (token === "yyyy") {
+ x = 4;
+ y = 4;
+ }
+ if (token === "yy") {
+ x = 2;
+ y = 2;
+ }
+ if (token === "y") {
+ x = 2;
+ y = 4;
+ }
+ year = getInt(val, iVal, x, y);
+ if (year === null) {
+ return NaN;
+ }
+ iVal += year.length;
+ if (year.length === 2) {
+ if (year > 70) {
+ year = 1900 + (year - 0);
+ } else {
+ year = 2000 + (year - 0);
+ }
+ }
+ } else if (token === "MMM" || token === "NNN") {
+ month = 0;
+ for (var i = 0; i < monthsAll.length; i++) {
+ var monthName = monthsAll[i];
+ if (val.substring(iVal, iVal + monthName.length).toLowerCase() === monthName.toLowerCase()) {
+ if (token === "MMM" || (token === "NNN" && i > 11)) {
+ month = i + 1;
+ if (month > 12) {
+ month -= 12;
+ }
+ iVal += monthName.length;
+ break;
+ }
+ }
+ }
+ if ((month < 1) || (month > 12)) {
+ return NaN;
+ }
+ } else if (token === "EE" || token === "E") {
+ for (var n = 0; n < daysAll.length; n++) {
+ var dayName = daysAll[n];
+ if (val.substring(iVal, iVal + dayName.length).toLowerCase() === dayName.toLowerCase()) {
+ iVal += dayName.length;
+ break;
+ }
+ }
+ } else if (token === "MM" || token === "M") {
+ month = getInt(val, iVal, token.length, 2);
+ if (month === null || (month < 1) || (month > 12)) {
+ return NaN;
+ }
+ iVal += month.length;
+ } else if (token === "dd" || token === "d") {
+ date = getInt(val, iVal, token.length, 2);
+ if (date === null || (date < 1) || (date > 31)) {
+ return NaN;
+ }
+ iVal += date.length;
+ } else if (token === "hh" || token === "h") {
+ hh = getInt(val, iVal, token.length, 2);
+ if (hh === null || (hh < 1) || (hh > 12)) {
+ return NaN;
+ }
+ iVal += hh.length;
+ } else if (token === "HH" || token === "H") {
+ hh = getInt(val, iVal, token.length, 2);
+ if (hh === null || (hh < 0) || (hh > 23)) {
+ return NaN;
+ }
+ iVal += hh.length;
+ } else if (token === "KK" || token === "K") {
+ hh = getInt(val, iVal, token.length, 2);
+ if (hh === null || (hh < 0) || (hh > 11)) {
+ return NaN;
+ }
+ iVal += hh.length;
+ } else if (token === "kk" || token === "k") {
+ hh = getInt(val, iVal, token.length, 2);
+ if (hh === null || (hh < 1) || (hh > 24)) {
+ return NaN;
+ }
+ iVal += hh.length;
+ hh--;
+ } else if (token === "mm" || token === "m") {
+ mm = getInt(val, iVal, token.length, 2);
+ if (mm === null || (mm < 0) || (mm > 59)) {
+ return NaN;
+ }
+ iVal += mm.length;
+ } else if (token === "ss" || token === "s") {
+ ss = getInt(val, iVal, token.length, 2);
+ if (ss === null || (ss < 0) || (ss > 59)) {
+ return NaN;
+ }
+ iVal += ss.length;
+ } else if (token === "a") {
+ if (val.substring(iVal, iVal + 2).toLowerCase() === "am") {
+ ampm = "AM";
+ } else if (val.substring(iVal, iVal + 2).toLowerCase() === "pm") {
+ ampm = "PM";
+ } else {
+ return NaN;
+ }
+ iVal += 2;
+ } else {
+ if (val.substring(iVal, iVal + token.length) !== token) {
+ return NaN;
+ } else {
+ iVal += token.length;
+ }
+ }
+ }
+ // If there are any trailing characters left in the value, it doesn't match
+ if (iVal !== val.length) {
+ return NaN;
+ }
+ // Is date valid for month?
+ if (month === 2) {
+ // Check for leap year
+ if (((year % 4 === 0) && (year % 100 !== 0)) || (year % 400 === 0)) { // leap year
+ if (date > 29) {
+ return NaN;
+ }
+ } else {
+ if (date > 28) {
+ return NaN;
+ }
+ }
+ }
+ if ((month === 4) || (month === 6) || (month === 9) || (month === 11)) {
+ if (date > 30) {
+ return NaN;
+ }
+ }
+ // Correct hours value
+ if (hh < 12 && ampm === "PM") {
+ hh = hh - 0 + 12;
+ } else if (hh > 11 && ampm === "AM") {
+ hh -= 12;
+ }
+ var newdate = new Date(year, month - 1, date, hh, mm, ss);
+ return newdate.getTime();
+ };
+
+
+ /** @ignore */
+ Cromag.parse = function (date, format) {
+ if (format) {
+ return getDateFromFormat(date, format);
+ }
+ var timestamp = Date.parse(date), minutesOffset = 0, match;
+ if (isNaN(timestamp) && (match = /^(\d{4}|[+\-]\d{6})-(\d{2})-(\d{2})(?:[T ](\d{2}):(\d{2})(?::(\d{2})(?:\.(\d{3,}))?)?(?:(Z)|([+\-])(\d{2})(?::?(\d{2}))?))?/.exec(date))) {
+ if (match[8] !== 'Z') {
+ minutesOffset = +match[10] * 60 + (+match[11]);
+
+ if (match[9] === '+') {
+ minutesOffset = 0 - minutesOffset;
+ }
+ }
+
+ timestamp = Cromag.UTC(+match[1], +match[2] - 1, +match[3], +match[4], +match[5] + minutesOffset, +match[6], +match[7].substr(0, 3));
+ }
+
+ return timestamp;
+ };
+
+ function polyfill(name, func) {
+ if (Cromag.prototype[name] === undefined) {
+ Cromag.prototype[name] = func;
+ }
+ }
+
+ /**
+ Returns new instance of Cromag object with the date set to today and
+ the time set to midnight
+ @returns {Cromag} Today's Date
+ @function
+ */
+ Cromag.today = function () {
+ return new Cromag().clearTime();
+ };
+
+ /**
+ Returns new instance of Cromag object with the date set to today and
+ the time set to midnight in UTC
+ @returns {Cromag} Today's Date in UTC
+ @function
+ */
+ Cromag.UTCtoday = function () {
+ return new Cromag().clearUTCTime();
+ };
+
+ /**
+ Returns new instance of Cromag object with the date set to tomorrow and
+ the time set to midnight
+ @returns {Cromag} Tomorrow's Date
+ @function
+ */
+ Cromag.tomorrow = function () {
+ return Cromag.today().add({days: 1});
+ };
+
+ /**
+ Returns new instance of Cromag object with the date set to tomorrow and
+ the time set to midnight in UTC
+ @returns {Cromag} Tomorrow's Date in UTC
+ @function
+ */
+ Cromag.UTCtomorrow = function () {
+ return Cromag.UTCtoday().add({days: 1});
+ };
+
+ /**
+ Returns new instance of Cromag object with the date set to yesterday and
+ the time set to midnight
+ @returns {Cromag} Yesterday's Date
+ @function
+ */
+ Cromag.yesterday = function () {
+ return Cromag.today().add({days: -1});
+ };
+
+ /**
+ Returns new instance of Cromag object with the date set to yesterday and
+ the time set to midnight in UTC
+ @returns {Cromag} Yesterday's Date in UTC
+ @function
+ */
+ Cromag.UTCyesterday = function () {
+ return Cromag.UTCtoday().add({days: -1});
+ };
+
+ Cromag.validateDay = function (day, year, month) {
+ var date = new Cromag(year, month, day);
+ return (date.getFullYear() === year &&
+ date.getMonth() === month &&
+ date.getDate() === day);
+ };
+
+ Cromag.validateYear = function (year) {
+ return (year >= 0 && year <= 9999);
+ };
+
+ Cromag.validateSecond = function (second) {
+ return (second >= 0 && second < 60);
+ };
+
+ Cromag.validateMonth = function (month) {
+ return (month >= 0 && month < 12);
+ };
+
+ Cromag.validateMinute = function (minute) {
+ return (minute >= 0 && minute < 60);
+ };
+
+ Cromag.validateMillisecond = function (milli) {
+ return (milli >= 0 && milli < 1000);
+ };
+
+ Cromag.validateHour = function (hour) {
+ return (hour >= 0 && hour < 24);
+ };
+
+ Cromag.compare = function (date1, date2) {
+ if (date1.valueOf() < date2.valueOf()) {
+ return -1;
+ } else if (date1.valueOf() > date2.valueOf()) {
+ return 1;
+ }
+ return 0;
+ };
+
+ Cromag.equals = function (date1, date2) {
+ return date1.valueOf() === date2.valueOf();
+ };
+
+
+ Cromag.getDayNumberFromName = function (name) {
+ return dayNames[name.toLowerCase()];
+ };
+
+
+ Cromag.getMonthNumberFromName = function (name) {
+ return monthNames[name.toLowerCase()];
+ };
+
+ Cromag.isLeapYear = function (year) {
+ return (new Cromag(year, 1, 29).getDate() === 29);
+ };
+
+ Cromag.getDaysInMonth = function (year, month) {
+ if (month === 1) {
+ return Cromag.isLeapYear(year) ? 29 : 28;
+ }
+ return daysInMonth[month];
+ };
+
+ function shadow(name) {
+ Cromag.prototype[name] = function () {
+ return this.date[name]();
+ };
+ }
+
+ function shadow1(name) {
+ Cromag.prototype[name] = function (arg) {
+ this.date[name](arg);
+ return this;
+ };
+ }
+
+
+ shadow('getDate');
+ shadow('getFullYear');
+ shadow('getYear');
+ shadow('getMilliseconds');
+ shadow('getHours');
+ shadow('getMinutes');
+ shadow('getMonth');
+ shadow('getSeconds');
+ shadow('getTime');
+ shadow('getTimezoneOffset');
+
+ shadow('getUTCDate');
+ shadow('getUTCDay');
+ shadow('getUTCFullYear');
+ shadow('getUTCHours');
+ shadow('getUTCMilliseconds');
+ shadow('getUTCMinutes');
+ shadow('getUTCMonth');
+ shadow('getUTCSeconds');
+
+ shadow1('setDate');
+ shadow1('setFullYear');
+ shadow1('setHours');
+ shadow1('setMilliseconds');
+ shadow1('setMinutes');
+ shadow1('setMonth');
+ shadow1('setSeconds');
+ shadow1('setTime');
+
+ shadow1('setUTCDate');
+ shadow1('setUTCFullYear');
+ shadow1('setUTCHours');
+ shadow1('setUTCMilliseconds');
+ shadow1('setUTCMinutes');
+ shadow1('setUTCMonth');
+ shadow1('setUTCSeconds');
+
+ shadow('toDateString');
+ shadow('toISOString');
+ shadow('toJSON');
+ shadow('toLocaleDateString');
+ shadow('toLocaleTimeString');
+ shadow('toString');
+ shadow('toTimeString');
+ shadow('toUTCString');
+ shadow('valueOf');
+
+
+ polyfill('getMonthAbbr', function () {
+ return monthsAbbr[this.getMonth()];
+ });
+
+ polyfill('getMonthName', function () {
+ return monthsFull[this.getMonth()];
+ });
+
+ polyfill('getUTCOffset', function () {
+ var tz = pad(Math.abs(this.getTimezoneOffset() / 0.6), 4);
+ if (this.getTimezoneOffset() > 0) {
+ tz = '-' + tz;
+ }
+ return tz;
+ });
+
+ polyfill('toCLFString', function () {
+ return pad(this.getDate(), 2) + '/' + this.getMonthAbbr() + '/' +
+ this.getFullYear() + ':' + pad(this.getHours(), 2) + ':' +
+ pad(this.getMinutes(), 2) + ':' + pad(this.getSeconds(), 2) +
+ ' ' + this.getUTCOffset();
+ });
+
+ polyfill('toYMD', function (separator) {
+ separator = typeof separator === 'undefined' ? '-' : separator;
+ return this.getUTCFullYear() + separator + pad(this.getUTCMonth() + 1, 2) +
+ separator + pad(this.getUTCDate(), 2);
+ });
+
+ polyfill('toDBString', function () {
+ return this.getUTCFullYear() + '-' + pad(this.getUTCMonth() + 1, 2) +
+ '-' + pad(this.getUTCDate(), 2) + ' ' + pad(this.getUTCHours(), 2) +
+ ':' + pad(this.getUTCMinutes(), 2) + ':' + pad(this.getUTCSeconds(), 2);
+ });
+
+ polyfill('clearTime', function () {
+ this.setHours(0);
+ this.setMinutes(0);
+ this.setSeconds(0);
+ this.setMilliseconds(0);
+
+ return this;
+ });
+
+ polyfill('clearUTCTime', function () {
+ this.setUTCHours(0);
+ this.setUTCMinutes(0);
+ this.setUTCSeconds(0);
+ this.setUTCMilliseconds(0);
+
+ return this;
+ });
+
+ polyfill('add', function (obj) {
+ if (obj.milliseconds !== undefined) {
+ this.setMilliseconds(this.getMilliseconds() + obj.milliseconds);
+ }
+ if (obj.seconds !== undefined) {
+ this.setSeconds(this.getSeconds() + obj.seconds);
+ }
+ if (obj.minutes !== undefined) {
+ this.setMinutes(this.getMinutes() + obj.minutes);
+ }
+ if (obj.hours !== undefined) {
+ this.setHours(this.getHours() + obj.hours);
+ }
+ if (obj.days !== undefined) {
+ this.setDate(this.getDate() + obj.days);
+ }
+ if (obj.months !== undefined) {
+ this.setMonth(this.getMonth() + obj.months);
+ }
+ if (obj.years !== undefined) {
+ this.setFullYear(this.getFullYear() + obj.years);
+ }
+ return this;
+ });
+
+ polyfill('addMilliseconds', function (milliseconds) {
+ return this.add({ milliseconds: milliseconds });
+ });
+
+ polyfill('addSeconds', function (seconds) {
+ return this.add({ seconds: seconds });
+ });
+
+ polyfill('addMinutes', function (minutes) {
+ return this.add({ minutes: minutes });
+ });
+
+ polyfill('addHours', function (hours) {
+ return this.add({ hours: hours });
+ });
+
+ polyfill('addDays', function (days) {
+ return this.add({ days: days });
+ });
+
+ polyfill('addWeeks', function (weeks) {
+ return this.add({ days: (weeks * 7) });
+ });
+
+ polyfill('addMonths', function (months) {
+ return this.add({ months: months });
+ });
+
+ polyfill('addYears', function (years) {
+ return this.add({ years: years });
+ });
+
+ polyfill('setTimeToNow', function () {
+ var n = new Date();
+ this.setMilliseconds(n.getMilliseconds());
+ this.setSeconds(n.getSeconds());
+ this.setMinutes(n.getMinutes());
+ this.setHours(n.getHours());
+ });
+
+ polyfill('clone', function () {
+ return new Cromag(this.valueOf());
+ });
+
+ polyfill('between', function (start, end) {
+ return (this.valueOf() >= start.valueOf() &&
+ this.valueOf() <= end.valueOf());
+ });
+
+ polyfill('compareTo', function (date) {
+ return Cromag.compare(this, date);
+ });
+
+ polyfill('equals', function (date) {
+ return Cromag.equals(this, date);
+ });
+
+ polyfill('isAfter', function (date) {
+ date = date ? date : new Cromag();
+ return (this.compareTo(date) > 0);
+ });
+
+ polyfill('isBefore', function (date) {
+ date = date ? date : new Cromag();
+ return (this.compareTo(date) < 0);
+ });
+
+ polyfill('getDaysBetween', function (date) {
+ return ((date.clone().valueOf() - this.valueOf()) / 86400000) | 0;
+ });
+
+ polyfill('getHoursBetween', function (date) {
+ return ((date.clone().valueOf() - this.valueOf()) / 3600000) | 0;
+ });
+
+ polyfill('getMinutesBetween', function (date) {
+ return ((date.clone().valueOf() - this.valueOf()) / 60000) | 0;
+ });
+
+ polyfill('getSecondsBetween', function (date) {
+ return ((date.clone().valueOf() - this.valueOf()) / 1000) | 0;
+ });
+
+ polyfill('getOrdinalNumber', function () {
+ return Math.ceil((this.clone().clearTime() - new Cromag(this.getFullYear(), 0, 1)) / 86400000) + 1;
+ });
+
+ polyfill('toFormat', function (format) {
+ format = format.replace('YYYY', this.getFullYear());
+ format = format.replace('YY', String(this.getFullYear()).slice(-2));
+ format = format.replace('MM', pad(this.getMonth() + 1, 2));
+ format = format.replace('DD', pad(this.getDate(), 2));
+ format = format.replace('HH24', pad(this.getHours(), 2));
+ format = format.replace('HH', pad((this.getHours() % 12), 2));
+ format = format.replace('MI', pad(this.getMinutes(), 2));
+ format = format.replace('SS', pad(this.getSeconds(), 2));
+
+ return format;
+ });
+
+
+ exports = module.exports = Cromag;
+}());
20 package.json
@@ -0,0 +1,20 @@
+{
+ "author": "Jerry Sievert <code@legitimatesounding.com> (http://legitimatesounding.com/blog/index.html)",
+ "name": "cromag",
+ "description": "Date and Time Without the Monkeys",
+ "version": "0.1.0",
+ "homepage": "https://github.com/JerrySievert/cromagjs",
+ "repository": {
+ "type": "git",
+ "url": "git://github.com/JerrySievert/cromagjs.git"
+ },
+ "main": "cromag.js",
+ "scripts": {
+ "test": "vows --spec"
+ },
+ "engines": {
+ "node": ">=0.4.0"
+ },
+ "dependencies": {},
+ "devDependencies": {}
+}
89 test/cromag-format-test.js
@@ -0,0 +1,89 @@
+var vows = require('vows');
+var assert = require('assert');
+
+var Cromag = require('../cromag');
+
+function pad(str, length) {
+ str = String(str);
+ while (str.length < length) {
+ str = '0' + str;
+ }
+ return str;
+}
+
+vows.describe('Cromag Format').addBatch({
+ 'can return month abbreviations as static method': {
+ topic: function () { return new Cromag(123456789); },
+ 'returns the correct abbreviated month': function (date) {
+ assert.equal(date.getMonthAbbr(), 'Jan');
+ }
+ },
+
+ 'can return month as static method': {
+ topic: function () { return new Cromag(123456789); },
+ 'returns the correct month': function (date) {
+ assert.equal(date.getMonthAbbr(), 'Jan');
+ }
+ },
+
+ 'can return common log formatted string': {
+ topic: function () { return new Cromag(Cromag.UTC(2011, 0, 1, 1, 1, 1, 0)); },
+ 'returns the correct clf string': function (date) {
+ var tz = pad(Math.abs(date.getTimezoneOffset() / 0.6), 4);
+ if (date.getTimezoneOffset() > 0) {
+ tz = '-' + tz;
+ }
+
+ date = new Cromag(date.valueOf() + date.getTimezoneOffset() * 60000);
+ assert.equal(date.toCLFString(), '01/Jan/2011:01:01:01 ' + tz);
+ }
+ },
+
+ 'can return correctly formatted toFormat': {
+ topic: function () { var topic = new Cromag(2011, 0, 1);
+ topic.addHours(13)
+ .addMinutes(11)
+ .addSeconds(41);
+ return topic;
+ },
+ 'returns correctly': function (date) {
+ assert.equal(date.toFormat('YYYY'), '2011');
+ assert.equal(date.toFormat('YY'), '11');
+ assert.equal(date.toFormat('MM'), '01');
+ assert.equal(date.toFormat('DD'), '01');
+ assert.equal(date.toFormat('HH'), '01');
+ assert.equal(date.toFormat('HH24'), '13');
+ assert.equal(date.toFormat('MI'), '11');
+ assert.equal(date.toFormat('SS'), '41');
+ }
+ },
+
+ 'can return database formatted string': {
+ topic: function () { return new Cromag(Cromag.UTC(2011, 0, 1, 1, 1, 1, 0)); },
+ 'returns the correct database string': function (date) {
+ assert.equal(date.toDBString(), '2011-01-01 01:01:01');
+ }
+ },
+
+ 'when passing an argument to toYMD': {
+ topic: function () { return new Cromag(Cromag.UTC(2011, 0, 1, 1, 1, 1, 0)).toYMD('-'); },
+ 'the correct string is returned': function (topic) {
+ assert.equal(topic, '2011-01-01');
+ }
+ },
+
+ 'when passing an empty argument to toYMD': {
+ topic: function () { return new Cromag(Cromag.UTC(2011, 0, 1, 1, 1, 1, 0)).toYMD(''); },
+ 'the correct string is returned': function (topic) {
+ assert.equal(topic, '20110101');
+ }
+ },
+
+ 'when passing no argument to toYMD': {
+ topic: function () { return new Cromag(Cromag.UTC(2011, 0, 1, 1, 1, 1, 0)).toYMD(); },
+ 'the correct default is chosen and the string is returned': function (topic) {
+ assert.equal(topic, '2011-01-01');
+ }
+ }
+
+}).export(module);
105 test/cromag-new-test.js
@@ -0,0 +1,105 @@
+var vows = require('vows');
+var assert = require('assert');
+
+var Cromag = require('../cromag');
+
+vows.describe('Cromag New').addBatch({
+ 'can return a new object from today static method': {
+ topic: function () { return Cromag.today(); },
+ 'returns the correct time': function (date) {
+ var compare = new Cromag().clearTime();
+ assert.equal(date.valueOf(), compare.valueOf());
+ }
+ },
+
+ 'clearTime() works': {
+ topic: function() { return new Cromag().clearTime(); },
+ 'returns the correct value': function (date) {
+ var compare = new Cromag();
+ compare.setHours(0);
+ compare.setMinutes(0);
+ compare.setSeconds(0);
+ compare.setMilliseconds(0);
+
+ assert.equal(date.valueOf(), compare.valueOf());
+ }
+ },
+
+ 'clearUTCTime() works': {
+ topic: function() { return new Cromag().clearUTCTime(); },
+ 'returns the correct value': function (date) {
+ var compare = new Cromag();
+ compare.setUTCHours(0);
+ compare.setUTCMinutes(0);
+ compare.setUTCSeconds(0);
+ compare.setUTCMilliseconds(0);
+
+ assert.equal(date.valueOf(), compare.valueOf());
+ }
+ },
+
+ 'today() works': {
+ topic: function() {
+ return Cromag.today();
+ },
+ 'returns the correct value': function(date) {
+ var compare = new Cromag().clearTime();
+ assert.equal(date.valueOf(), compare.valueOf());
+ }
+ },
+
+ 'UTCtoday() works': {
+ topic: function() {
+ return Cromag.UTCtoday();
+ },
+ 'returns the correct value': function(date) {
+ var compare = new Cromag().clearUTCTime();
+ assert.equal(date.valueOf(), compare.valueOf());
+ }
+ },
+
+ 'yesterday() works': {
+ topic: function() {
+ return Cromag.yesterday();
+ },
+ 'returns the correct value': function(date) {
+ var compare = new Cromag().clearTime();
+ compare.setSeconds(compare.getSeconds() - 86400);
+ assert.equal(date.valueOf(), compare.valueOf());
+ }
+ },
+
+ 'UTCyesterday() works': {
+ topic: function() {
+ return Cromag.UTCyesterday();
+ },
+ 'returns the correct value': function(date) {
+ var compare = new Cromag().clearUTCTime();
+ compare.setSeconds(compare.getSeconds() - 86400);
+ assert.equal(date.valueOf(), compare.valueOf());
+ }
+ },
+
+ 'tomorrow() works': {
+ topic: function() {
+ return Cromag.tomorrow();
+ },
+ 'returns the correct value': function(date) {
+ var compare = new Cromag().clearTime();
+ compare.setSeconds(compare.getSeconds() + 86400);
+ assert.equal(date.valueOf(), compare.valueOf());
+ }
+ },
+
+ 'UTCtomorrow() works': {
+ topic: function() {
+ return Cromag.UTCtomorrow();
+ },
+ 'returns the correct value': function(date) {
+ var compare = new Cromag().clearUTCTime();
+ compare.setSeconds(compare.getSeconds() + 86400);
+ assert.equal(date.valueOf(), compare.valueOf());
+ }
+ }
+
+}).export(module);
128 test/cromag-parse-test.js
@@ -0,0 +1,128 @@
+var vows = require('vows');
+var assert = require('assert');
+
+var Cromag = require('../cromag');
+
+vows.describe('Cromag Parse').addBatch({
+ 'can instantiate milliseconds': {
+ topic: function () { return new Cromag(123456789); },
+ 'returns a valid date object': function (date) {
+ assert.ok(date);
+ },
+ 'returns a correct value': function (date) {
+ assert.equal(date.valueOf(), 123456789);
+ }
+ },
+
+ 'can instantiate string': {
+ topic: function () { return new Cromag('Jan 1, 2011 01:01:01 GMT'); },
+ 'returns a valid date object': function (date) {
+ assert.ok(date);
+ },
+ 'returns a correct value': function (date) {
+ assert.equal(date.valueOf(), 1293843661000);
+ }
+ },
+
+ 'can instantiate arguments': {
+ topic: function () { return new Cromag(2011, 1, 1, 1, 1, 1, 0); },
+ 'returns a valid date object': function (date) {
+ assert.ok(date);
+ }
+ },
+
+ 'can parse normal date': {
+ topic: function () { return Cromag.parse('Jan 1, 2011 01:01:01 GMT'); },
+ 'returns a correct value': function (milli) {
+ assert.equal(milli, 1293843661000);
+ }
+ },
+ 'can parse ISO-8601': {
+ topic: function () { return Cromag.parse('2011-01-01T01:01:01Z'); },
+ 'returns a correct value': function (milli) {
+ assert.equal(milli, 1293843661000);
+ }
+ },
+ 'can parse custom format': {
+ topic: function () {
+ return Cromag.parse('20/6/2011 8:30', 'd/M/y H:m');
+ },
+ 'returns a correct value': function (milli) {
+ var against = new Cromag(2011, 5, 20, 8, 30, 0);
+ assert.equal(milli, against.valueOf());
+ }
+ },
+ 'parse custom format with full month name': {
+ topic: function () {
+ return Cromag.parse('June 20, 2011 08:30:00', 'MMM d, y H:m:s');
+ },
+ 'returns a correct value': function (milli) {
+ var against = new Cromag(2011, 5, 20, 8, 30, 0);
+ assert.equal(milli, against.valueOf());
+ }
+ },
+ 'parse custom format with abbr month name': {
+ topic: function () {
+ return Cromag.parse('Jun 20, 2011 08:30:00', 'MMM d, y H:m:s');
+ },
+ 'returns a correct value': function (milli) {
+ var against = new Cromag(2011, 5, 20, 8, 30, 0);
+ assert.equal(milli, against.valueOf());
+ }
+ },
+ 'parse custom format with 12 hr clock': {
+ topic: function () {
+ return Cromag.parse('June 20, 2011 08:30:00AM', 'MMM d, y h:m:sa');
+ },
+ 'returns a correct value': function (milli) {
+ var against = new Cromag(2011, 5, 20, 8, 30, 0);
+ assert.equal(milli, against.valueOf());
+ }
+ },
+ 'parse mysql date format': {
+ topic: function () {
+ return Cromag.parse('2011-06-20 08:30:00', 'y-M-d H:m:s');
+ },
+ 'returns a correct value': function (milli) {
+ var against = new Cromag(2011, 5, 20, 8, 30, 0);
+ assert.equal(milli, against.valueOf());
+ }
+ },
+ 'parse us date format w/o time': {
+ topic: function () {
+ return Cromag.parse('6/20/2011', 'M/d/y');
+ },
+ 'returns a correct value': function (milli) {
+ var against = new Cromag(2011, 5, 20);
+ assert.equal(milli, against.valueOf());
+ }
+ },
+ 'parse us date format with time': {
+ topic: function () {
+ return Cromag.parse('6/20/2011 00:00:01', 'M/d/y H:m:s');
+ },
+ 'returns a correct value': function (milli) {
+ var against = new Cromag(2011, 5, 20, 0, 0, 1);
+ assert.equal(milli, against.valueOf());
+ }
+ },
+ 'parse uk date format w/o time': {
+ topic: function () {
+ return Cromag.parse('20/6/2011', 'd/M/y');
+ },
+ 'returns a correct value': function (milli) {
+ var against = new Cromag(2011, 5, 20);
+ assert.equal(milli, against.valueOf());
+ }
+ },
+ 'parse uk date format with time': {
+ topic: function () {
+
+ return Cromag.parse('20/6/2011 00:00:01', 'd/M/y H:m:s');
+ },
+ 'returns a correct value': function (milli) {
+ var against = new Cromag(2011, 5, 20, 0, 0, 1);
+ assert.equal(milli, against.valueOf());
+ }
+ }
+}).export(module);
560 test/cromag-validate-test.js
@@ -0,0 +1,560 @@
+var vows = require('vows');
+var assert = require('assert');
+
+var Cromag = require('../cromag');
+
+vows.describe('Cromag Validate').addBatch({
+ 'can deal with hours': {
+ topic: function () { return Cromag; },
+ 'false for less than 0': function (topic) {
+ assert.equal(topic.validateHour(-1), false);
+ },
+ 'false for greater than 23': function (topic) {
+ assert.equal(topic.validateHour(24), false);
+ },
+ 'true for in range': function (topic) {
+ assert.equal(topic.validateHour(12), true);
+ }
+ },
+
+ 'can deal with minutes': {
+ topic: function () { return Cromag; },
+ 'false for less than 0': function (topic) {
+ assert.equal(topic.validateMinute(-1), false);
+ },
+ 'false for greater than 59': function (topic) {
+ assert.equal(topic.validateMinute(60), false);
+ },
+ 'true for in range': function (topic) {
+ assert.equal(topic.validateMinute(30), true);
+ }
+ },
+
+ 'can deal with seconds': {
+ topic: function () { return Cromag; },
+ 'false for less than 0': function (topic) {
+ assert.equal(topic.validateSecond(-1), false);
+ },
+ 'false for greater than 59': function (topic) {
+ assert.equal(topic.validateSecond(60), false);
+ },
+ 'true for in range': function (topic) {
+ assert.equal(topic.validateSecond(30), true);
+ }
+ },
+
+ 'can deal with milliseconds': {
+ topic: function () { return Cromag; },
+ 'false for less than 0': function (topic) {
+ assert.equal(topic.validateMillisecond(-1), false);
+ },
+ 'false for greater than 999': function (topic) {
+ assert.equal(topic.validateMillisecond(1000), false);
+ },
+ 'true for in range': function (topic) {
+ assert.equal(topic.validateMillisecond(500), true);
+ }
+ },
+
+ 'can deal with years': {
+ topic: function () { return Cromag; },
+ 'false for less than 0': function (topic) {
+ assert.equal(topic.validateYear(-1), false);
+ },
+ 'false for greater than 9999': function (topic) {
+ assert.equal(topic.validateYear(10000), false);
+ },
+ 'true for in range': function (topic) {
+ assert.equal(topic.validateYear(5000), true);
+ }
+ },
+
+ 'can deal with days': {
+ topic: function () { return Cromag; },
+ 'false for less than 0': function (topic) {
+ assert.equal(topic.validateDay(-1, 2011, 12), false);
+ },
+ 'false for greater than 31': function (topic) {
+ assert.equal(topic.validateDay(32, 2011, 12), false);
+ },
+ 'true for in range': function (topic) {
+ assert.equal(topic.validateDay(10, 2011, 11), true);
+ }
+ },
+
+ 'static compare works': {
+ topic: function () { return Cromag.today(); },
+ '-1 for yesterday': function (topic) {
+ assert.equal(Cromag.compare(Cromag.yesterday(), topic), -1);
+ },
+ '1 for tomorrow': function (topic) {
+ assert.equal(Cromag.compare(Cromag.tomorrow(), topic), 1);
+ },
+ '0 for today': function (topic) {
+ assert.equal(Cromag.compare(Cromag.today(), topic), 0);
+ }
+ },
+
+ 'static equals works': {
+ topic: function () { return Cromag.today(); },
+ 'equal for today': function (topic) {
+ assert.equal(Cromag.equals(topic, Cromag.today()), true);
+ },
+ 'false for tomorrow': function (topic) {
+ assert.equal(Cromag.equals(topic, Cromag.tomorrow()), false);
+ },
+ 'false for yesterday': function (topic) {
+ assert.equal(Cromag.equals(topic, Cromag.yesterday()), false);
+ }
+ },
+
+ 'getDayNumberFromName works': {
+ topic: function () { return Cromag; },
+ 'sunday works': function (topic) {
+ assert.equal(topic.getDayNumberFromName('sunday'), 0);
+ },
+ 'sun works': function (topic) {
+ assert.equal(topic.getDayNumberFromName('sun'), 0);
+ },
+ 'su works': function (topic) {
+ assert.equal(topic.getDayNumberFromName('su'), 0);
+ },
+ 'monday works': function (topic) {
+ assert.equal(topic.getDayNumberFromName('monday'), 1);
+ },
+ 'mon works': function (topic) {
+ assert.equal(topic.getDayNumberFromName('mon'), 1);
+ },
+ 'mo works': function (topic) {
+ assert.equal(topic.getDayNumberFromName('mo'), 1);
+ },
+ 'tuesday works': function (topic) {
+ assert.equal(topic.getDayNumberFromName('tuesday'), 2);
+ },
+ 'tue works': function (topic) {
+ assert.equal(topic.getDayNumberFromName('tue'), 2);
+ },
+ 'tu works': function (topic) {
+ assert.equal(topic.getDayNumberFromName('tu'), 2);
+ },
+ 'wednesday works': function (topic) {
+ assert.equal(topic.getDayNumberFromName('wednesday'), 3);
+ },
+ 'wed works': function (topic) {
+ assert.equal(topic.getDayNumberFromName('wed'), 3);
+ },
+ 'we works': function (topic) {
+ assert.equal(topic.getDayNumberFromName('we'), 3);
+ },
+ 'thursday works': function (topic) {
+ assert.equal(topic.getDayNumberFromName('thursday'), 4);
+ },
+ 'thu works': function (topic) {
+ assert.equal(topic.getDayNumberFromName('thu'), 4);
+ },
+ 'th works': function (topic) {
+ assert.equal(topic.getDayNumberFromName('th'), 4);
+ },
+ 'friday works': function (topic) {
+ assert.equal(topic.getDayNumberFromName('friday'), 5);
+ },
+ 'fri works': function (topic) {
+ assert.equal(topic.getDayNumberFromName('fri'), 5);
+ },
+ 'fr works': function (topic) {
+ assert.equal(topic.getDayNumberFromName('fr'), 5);
+ },
+ 'saturday works': function (topic) {
+ assert.equal(topic.getDayNumberFromName('saturday'), 6);
+ },
+ 'sat works': function (topic) {
+ assert.equal(topic.getDayNumberFromName('sat'), 6);
+ },
+ 'sa works': function (topic) {
+ assert.equal(topic.getDayNumberFromName('sa'), 6);
+ },
+ 'everything else does not': function (topic) {
+ assert.equal(topic.getDayNumberFromName('junk'), undefined);
+ }
+ },
+
+ 'getMonthNumberFromName works': {
+ topic: function () { return Cromag; },
+ 'january works': function (topic) {
+ assert.equal(topic.getMonthNumberFromName('january'), 0);
+ },
+ 'jan works': function (topic) {
+ assert.equal(topic.getMonthNumberFromName('jan'), 0);
+ },
+ 'february works': function (topic) {
+ assert.equal(topic.getMonthNumberFromName('february'), 1);
+ },
+ 'feb works': function (topic) {
+ assert.equal(topic.getMonthNumberFromName('feb'), 1);
+ },
+ 'march works': function (topic) {
+ assert.equal(topic.getMonthNumberFromName('march'), 2);
+ },
+ 'mar works': function (topic) {
+ assert.equal(topic.getMonthNumberFromName('mar'), 2);
+ },
+ 'april works': function (topic) {
+ assert.equal(topic.getMonthNumberFromName('april'), 3);
+ },
+ 'apr works': function (topic) {
+ assert.equal(topic.getMonthNumberFromName('apr'), 3);
+ },
+ 'may works': function (topic) {
+ assert.equal(topic.getMonthNumberFromName('may'), 4);
+ },
+ 'june works': function (topic) {
+ assert.equal(topic.getMonthNumberFromName('june'), 5);
+ },
+ 'jun works': function (topic) {
+ assert.equal(topic.getMonthNumberFromName('jun'), 5);
+ },
+ 'july works': function (topic) {
+ assert.equal(topic.getMonthNumberFromName('july'), 6);
+ },
+ 'jul works': function (topic) {
+ assert.equal(topic.getMonthNumberFromName('jul'), 6);
+ },
+ 'august works': function (topic) {
+ assert.equal(topic.getMonthNumberFromName('august'), 7);
+ },
+ 'aug works': function (topic) {
+ assert.equal(topic.getMonthNumberFromName('aug'), 7);
+ },
+ 'september works': function (topic) {
+ assert.equal(topic.getMonthNumberFromName('september'), 8);
+ },
+ 'sep works': function (topic) {
+ assert.equal(topic.getMonthNumberFromName('sep'), 8);
+ },
+ 'october works': function (topic) {
+ assert.equal(topic.getMonthNumberFromName('october'), 9);
+ },
+ 'oct works': function (topic) {
+ assert.equal(topic.getMonthNumberFromName('oct'), 9);
+ },
+ 'november works': function (topic) {
+ assert.equal(topic.getMonthNumberFromName('november'), 10);
+ },
+ 'nov works': function (topic) {
+ assert.equal(topic.getMonthNumberFromName('nov'), 10);
+ },
+ 'december works': function (topic) {
+ assert.equal(topic.getMonthNumberFromName('december'), 11);
+ },
+ 'dec works': function (topic) {
+ assert.equal(topic.getMonthNumberFromName('dec'), 11);
+ }
+ },
+
+ 'can add milliseconds': {
+ 'adding positive milliseconds works': function () {
+ var topic = Cromag.today();
+ topic.addMilliseconds(500);
+ assert.equal(topic.getMilliseconds(), 500);
+ },
+ 'adding negative milliseconds works': function () {
+ var topic = Cromag.today();
+ topic.addMilliseconds(500);
+ assert.equal(topic.getMilliseconds(), 500);
+ topic.addMilliseconds(-250);
+ assert.equal(topic.getMilliseconds(), 250);
+ }
+ },
+
+ 'can add seconds': {
+ 'adding positive seconds works': function () {
+ var topic = Cromag.today();
+ topic.addSeconds(50);
+ assert.equal(topic.getSeconds(), 50);
+ },
+ 'adding negative seconds works': function () {
+ var topic = Cromag.today();
+ topic.addSeconds(50);
+ assert.equal(topic.getSeconds(), 50);
+ topic.addSeconds(-25);
+ assert.equal(topic.getSeconds(), 25);
+ }
+ },
+
+ 'can add minutes': {
+ 'adding positive minutes works': function () {
+ var topic = Cromag.today();
+ topic.addMinutes(50);
+ assert.equal(topic.getMinutes(), 50);
+ },
+ 'adding negative minutes works': function () {
+ var topic = Cromag.today();
+ topic.addMinutes(50);
+ assert.equal(topic.getMinutes(), 50);
+ topic.addMinutes(-25);
+ assert.equal(topic.getMinutes(), 25);
+ }
+ },
+
+ 'can add hours': {
+ 'adding positive hours works': function () {
+ var topic = Cromag.today();
+ topic.addHours(5);
+ assert.equal(topic.getHours(), 5);
+ },
+ 'adding negative hours works': function () {
+ var topic = Cromag.today();
+ topic.addHours(5);
+ assert.equal(topic.getHours(), 5);
+ topic.addHours(-2);
+ assert.equal(topic.getHours(), 3);
+ }
+ },
+
+ 'can add days': {
+ 'adding positive days works': function () {
+ var topic = new Cromag(2011, 0, 10);
+ topic.addDays(1);
+ assert.equal(topic.getDate(), 11);
+ },
+ 'adding negative days works': function () {
+ var topic = new Cromag(2011, 0, 10);
+ topic.addDays(1);
+ assert.equal(topic.getDate(), 11);
+ topic.addDays(-2);
+ assert.equal(topic.getDate(), 9);
+ }
+ },
+
+ 'can add weeks': {
+ 'adding positive weeks works': function () {
+ var topic = new Cromag(2011, 0, 10);
+ topic.addWeeks(1);
+ assert.equal(topic.getDate(), 17);
+ },
+ 'adding negative weeks works': function () {
+ var topic = new Cromag(2011, 0, 10);
+ topic.addWeeks(1);
+ assert.equal(topic.getDate(), 17);
+ topic.addWeeks(-2);
+ assert.equal(topic.getDate(), 3);
+ }
+ },
+
+ 'can add months': {
+ 'adding positive months works': function () {
+ var topic = new Cromag(2011, 1, 10);
+ topic.addMonths(1);
+ assert.equal(topic.getMonth(), 2);
+ },
+ 'adding negative months works': function () {
+ var topic = new Cromag(2011, 1, 10);
+ topic.addMonths(1);
+ assert.equal(topic.getMonth(), 2);
+ topic.addMonths(-2);
+ assert.equal(topic.getMonth(), 0);
+ }
+ },
+
+ 'can set time to now': {
+ 'setting time to now works': function () {
+ var topic = Cromag.today();
+ topic.setTimeToNow();
+ var now = new Cromag();
+
+ // hokey, but should be sufficient
+ assert.equal((now.valueOf() - topic.valueOf() < 100), true);
+ }
+ },
+
+ 'can clone time': {
+ topic: function () { return new Cromag(); },
+ 'clone works': function (topic) {
+ var clone = topic.clone();
+ assert.equal(clone.valueOf(), topic.valueOf());
+ }
+ },
+
+ 'between works': {
+ 'between returns true for valid start and end': function () {
+ var today = Cromag.today();
+ var yesterday = Cromag.yesterday();
+ var tomorrow = Cromag.tomorrow();
+ assert.equal(today.between(yesterday, tomorrow), true);
+ },
+ 'between returns false for invalid start and end': function () {
+ var today = Cromag.today();
+ var yesterday = Cromag.yesterday();
+ var tomorrow = Cromag.tomorrow();
+ assert.equal(today.between(tomorrow, yesterday), false);
+ }
+ },
+
+ 'compareTo works': {
+ topic: function () { return Cromag.today(); },
+ '-1 for tomorrow': function (topic) {
+ assert.equal(topic.compareTo(Cromag.tomorrow()), -1);
+ },
+ '1 for yesterday': function (topic) {
+ assert.equal(topic.compareTo(Cromag.yesterday()), 1);
+ },
+ '0 for today': function (topic) {
+ assert.equal(topic.compareTo(Cromag.today()), 0);
+ }
+ },
+
+
+ 'equals instance works': {
+ topic: function () { return Cromag.today(); },
+ 'true for equal': function (topic) {
+ assert.equal(topic.equals(Cromag.today()), true);
+ },
+ 'false for not equal': function (topic) {
+ assert.equal(topic.equals(Cromag.tomorrow()), false);
+ }
+ },
+
+ 'isBefore works': {
+ topic: function () { return Cromag.today(); },
+ 'true for before': function (topic) {
+ assert.equal(topic.isBefore(Cromag.tomorrow()), true);
+ },
+ 'false for after': function (topic) {
+ assert.equal(topic.isBefore(Cromag.yesterday()), false);
+ }
+ },
+
+ 'isAfter works': {
+ topic: function () { return Cromag.today(); },
+ 'false for before': function (topic) {
+ assert.equal(topic.isAfter(Cromag.tomorrow()), false);
+ },
+ 'true for after': function (topic) {
+ assert.equal(topic.isAfter(Cromag.yesterday()), true);
+ }
+ },
+
+ 'getDaysBetween works': {
+ topic: function () { return Cromag.today(); },
+ '1 for tomorrow': function (topic) {
+ assert.equal(topic.getDaysBetween(Cromag.tomorrow()), 1);
+ },
+ '-1 for yesterday': function (topic) {
+ assert.equal(topic.getDaysBetween(Cromag.yesterday()), -1);
+ },
+ '0 for today': function (topic) {
+ assert.equal(topic.getDaysBetween(Cromag.today()), 0);
+ }
+ },
+
+ 'getDaysBetween works for beginning of year': {
+ topic: function () { return new Cromag('Jan 1, 2011 01:01:01 GMT'); },
+ 'should return 0 for the same day': function (topic) {
+ var date = new Cromag('Jan 1, 2011 01:01:01 GMT');
+ assert.equal(topic.getDaysBetween(date), 0);
+ },
+ 'should return 1 for tomorrow': function (topic) {
+ var date = new Cromag('Jan 2, 2011 01:01:01 GMT');
+ assert.equal(topic.getDaysBetween(date), 1);
+ }
+ },
+
+ 'getMinutesBetween works': {
+ topic: function () { return new Cromag('Jan 1, 2011 23:31:01 GMT'); },
+ '10 for 10 minutes': function (topic) {
+ assert.equal(topic.getMinutesBetween(new Cromag('Jan 1, 2011 23:41:01 GMT')), 10);
+ },
+ '-10 for 10 minutes ago': function (topic) {
+ assert.equal(topic.getMinutesBetween(new Cromag('Jan 1, 2011 23:21:01 GMT')), -10);
+ },
+ '0 for same minute': function (topic) {
+ assert.equal(topic.getMinutesBetween(new Cromag('Jan 1, 2011 23:31:01 GMT')), 0);
+ },
+ 'for time difference that spans days': function (topic) {
+ assert.equal(topic.getMinutesBetween(new Cromag('Jan 2, 2011 00:01:01 GMT')), 30);
+ }
+ },
+
+ 'getSecondsBetween works': {
+ topic: function () { return new Cromag('Jan 1, 2011 23:31:01 GMT'); },
+ '10 for 10 seconds': function (topic) {
+ assert.equal(topic.getSecondsBetween(new Cromag('Jan 1, 2011 23:31:11 GMT')), 10);
+ },
+ '-10 for 10 seconds ago': function (topic) {
+ assert.equal(topic.getSecondsBetween(new Cromag('Jan 1, 2011 23:30:51 GMT')), -10);
+ },
+ '0 for same second': function (topic) {
+ assert.equal(topic.getSecondsBetween(new Cromag('Jan 1, 2011 23:31:01 GMT')), 0);
+ }
+ },
+
+ 'getHoursBetween works': {
+ topic: function () { return new Cromag('Jan 1, 2011 23:31:01 GMT'); },
+ '1 for 1 hour': function (topic) {
+ assert.equal(topic.getHoursBetween(new Cromag('Jan 2, 2011 00:31:01 GMT')), 1);
+ },
+ '-1 for 1 hour ago': function (topic) {
+ assert.equal(topic.getHoursBetween(new Cromag('Jan 1, 2011 22:31:01 GMT')), -1);
+ },
+ '0 for same hour': function (topic) {
+ assert.equal(topic.getHoursBetween(new Cromag('Jan 1, 2011 23:31:01 GMT')), 0);
+ }
+ },
+
+ 'getOrdinalNumber works': {
+ 'returns correct day': function () {
+ var date = new Cromag('02-01-2011');
+ assert.equal(date.getOrdinalNumber(), 32);
+ }
+ },
+
+ 'getOrdinalNumber works for january 1st': {
+ 'returns correct day': function () {
+ var date = new Cromag('01-01-2011');
+ assert.equal(date.getOrdinalNumber(), 1);
+ }
+ },
+
+ 'getDaysInMonth works': {
+ 'january': function (topic) {
+ assert.equal(Cromag.getDaysInMonth(2011, 0), 31);
+ },
+ 'february': function (topic) {
+ assert.equal(Cromag.getDaysInMonth(2011, 1), 28);
+ },
+ 'february leap year': function (topic) {
+ assert.equal(Cromag.getDaysInMonth(2008, 1), 29);
+ },
+ 'march': function (topic) {
+ assert.equal(Cromag.getDaysInMonth(2011, 2), 31);
+ },
+ 'april': function (topic) {
+ assert.equal(Cromag.getDaysInMonth(2011, 3), 30);
+ },
+ 'may': function (topic) {
+ assert.equal(Cromag.getDaysInMonth(2011, 4), 31);
+ },
+ 'june': function (topic) {
+ assert.equal(Cromag.getDaysInMonth(2011, 5), 30);
+ },
+ 'july': function (topic) {
+ assert.equal(Cromag.getDaysInMonth(2011, 6), 31);
+ },
+ 'august': function (topic) {
+ assert.equal(Cromag.getDaysInMonth(2011, 7), 31);
+ },
+ 'september': function (topic) {
+ assert.equal(Cromag.getDaysInMonth(2011, 8), 30);
+ },
+ 'october': function (topic) {
+ assert.equal(Cromag.getDaysInMonth(2011, 9), 31);
+ },
+ 'november': function (topic) {
+ assert.equal(Cromag.getDaysInMonth(2011, 10), 30);
+ },
+ 'december': function (topic) {
+ assert.equal(Cromag.getDaysInMonth(2011, 11), 31);
+ }
+ }
+
+}).export(module);
Please sign in to comment.
Something went wrong with that request. Please try again.