date-format 2.1.0 → 3.0.0

package/lib/index.js

@@ -30,10 +30,6 @@ function offset(timezoneOffset) {
   return timezoneOffset < 0 ? "+" + h + m : "-" + h + m;
 }
 
-function datePart(date, displayUTC, part) {
-  return displayUTC ? date["getUTC" + part]() : date["get" + part]();
-}
-
 function asString(format, date) {
   if (typeof format !== "string") {
     date = format;
@@ -43,20 +39,19 @@ function asString(format, date) {
     date = module.exports.now();
   }
 
-  var displayUTC = format.indexOf("O") > -1;
+  // Issue # 14 - Per ISO8601 standard, the time string should be local time
+  // with timezone info.
+  // See https://en.wikipedia.org/wiki/ISO_8601 section "Time offsets from UTC"
 
-  var vDay = addZero(datePart(date, displayUTC, "Date"));
-  var vMonth = addZero(datePart(date, displayUTC, "Month") + 1);
-  var vYearLong = addZero(datePart(date, displayUTC, "FullYear"));
+  var vDay = addZero(date.getDate());
+  var vMonth = addZero(date.getMonth() + 1);
+  var vYearLong = addZero(date.getFullYear());
   var vYearShort = addZero(vYearLong.substring(2, 4));
   var vYear = format.indexOf("yyyy") > -1 ? vYearLong : vYearShort;
-  var vHour = addZero(datePart(date, displayUTC, "Hours"));
-  var vMinute = addZero(datePart(date, displayUTC, "Minutes"));
-  var vSecond = addZero(datePart(date, displayUTC, "Seconds"));
-  var vMillisecond = padWithZeros(
-    datePart(date, displayUTC, "Milliseconds"),
-    3
-  );
+  var vHour = addZero(date.getHours());
+  var vMinute = addZero(date.getMinutes());
+  var vSecond = addZero(date.getSeconds());
+  var vMillisecond = padWithZeros(date.getMilliseconds(), 3);
   var vTimeZone = offset(date.getTimezoneOffset());
   var formatted = format
     .replace(/dd/g, vDay)
@@ -70,55 +65,63 @@ function asString(format, date) {
   return formatted;
 }
 
+function setDatePart(date, part, value, local) {
+  date['set' + (local ? '' : 'UTC') + part](value);
+}
+
 function extractDateParts(pattern, str, missingValuesDate) {
+  // Javascript Date object doesn't support custom timezone.  Sets all felds as
+  // GMT based to begin with.  If the timezone offset is provided, then adjust
+  // it using provided timezone, otherwise, adjust it with the system timezone.
+  var local = pattern.indexOf('O') < 0;
   var matchers = [
     {
       pattern: /y{1,4}/,
       regexp: "\\d{1,4}",
       fn: function(date, value) {
-        date.setFullYear(value);
+        setDatePart(date, 'FullYear', value, local);
       }
     },
     {
       pattern: /MM/,
       regexp: "\\d{1,2}",
       fn: function(date, value) {
-        date.setMonth(value - 1);
+        setDatePart(date, 'Month', (value - 1), local);
       }
     },
     {
       pattern: /dd/,
       regexp: "\\d{1,2}",
       fn: function(date, value) {
-        date.setDate(value);
+        setDatePart(date, 'Date', value, local);
       }
     },
     {
       pattern: /hh/,
       regexp: "\\d{1,2}",
       fn: function(date, value) {
-        date.setHours(value);
+        setDatePart(date, 'Hours', value, local);
       }
     },
     {
       pattern: /mm/,
       regexp: "\\d\\d",
       fn: function(date, value) {
-        date.setMinutes(value);
+        setDatePart(date, 'Minutes', value, local);
       }
     },
     {
       pattern: /ss/,
       regexp: "\\d\\d",
       fn: function(date, value) {
-        date.setSeconds(value);
+        setDatePart(date, 'Seconds', value, local);
       }
     },
     {
       pattern: /SSS/,
       regexp: "\\d\\d\\d",
       fn: function(date, value) {
-        date.setMilliseconds(value);
+        setDatePart(date, 'Milliseconds', value, local);
       }
     },
     {
@@ -129,8 +132,28 @@ function extractDateParts(pattern, str, missingValuesDate) {
           value = 0;
         }
         var offset = Math.abs(value);
-        var minutes = (offset % 100) + Math.floor(offset / 100) * 60;
-        date.setMinutes(date.getMinutes() + (value > 0 ? minutes : -minutes));
+        var timezoneOffset = (value > 0 ? -1 :  1 ) * ((offset % 100) + Math.floor(offset / 100) * 60);
+        // Per ISO8601 standard: UTC = local time - offset
+        //
+        // For example, 2000-01-01T01:00:00-0700
+        //   local time: 2000-01-01T01:00:00
+        //   ==> UTC   : 2000-01-01T08:00:00 ( 01 - (-7) = 8 )
+        //
+        // To make it even more confusing, the date.getTimezoneOffset() is
+        // opposite sign of offset string in the ISO8601 standard.  So if offset
+        // is '-0700' the getTimezoneOffset() would be (+)420. The line above
+        // calculates timezoneOffset to matche Javascript's behavior.
+        //
+        // The date/time of the input is actually the local time, so the date
+        // object that was constructed is actually local time even thought the
+        // UTC setters are used.  This means the date object's internal UTC
+        // representation was wrong.  It needs to be fixed by substracting the
+        // offset (or adding the offset minutes as they are opposite sign).
+        //
+        // Note: the time zone has to be processed after all other fileds are
+        // set.  The result would be incorrect if the offset was calculated
+        // first then overriden by the other filed setters.
+        date.setUTCMinutes(date.getUTCMinutes() + timezoneOffset);
       }
     }
   ];
@@ -162,6 +185,7 @@ function extractDateParts(pattern, str, missingValuesDate) {
     dateFns.forEach(function(f, i) {
       f.fn(date, matches[i + 1]);
     });
+
     return date;
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "date-format",
-  "version": "2.1.0",
+  "version": "3.0.0",
   "description": "Formatting Date objects as strings since 2013",
   "main": "lib/index.js",
   "repository": {

package/test/date_format-test.js

@@ -29,23 +29,21 @@ describe('date_format', function() {
 
     it('should provide a ISO8601 with timezone offset format', function() {
         var tzDate = createFixedDate();
-        tzDate.setMinutes(tzDate.getMinutes() - tzDate.getTimezoneOffset() - 660);
         tzDate.getTimezoneOffset = function () {
             return -660;
         };
 
-        // when tz offset is in the pattern, the date should be in UTC
+        // when tz offset is in the pattern, the date should be in local time
         dateFormat.asString(dateFormat.ISO8601_WITH_TZ_OFFSET_FORMAT, tzDate)
-            .should.eql('2010-01-11T03:31:30.005+1100');
+            .should.eql('2010-01-11T14:31:30.005+1100');
 
         tzDate = createFixedDate();
-        tzDate.setMinutes((tzDate.getMinutes() - tzDate.getTimezoneOffset()) + 120);
         tzDate.getTimezoneOffset = function () {
             return 120;
         };
 
         dateFormat.asString(dateFormat.ISO8601_WITH_TZ_OFFSET_FORMAT, tzDate)
-            .should.eql('2010-01-11T16:31:30.005-0200');
+            .should.eql('2010-01-11T14:31:30.005-0200');
     });
 
     it('should provide a just-the-time format', function() {
@@ -54,11 +52,10 @@ describe('date_format', function() {
 
     it('should provide a custom format', function() {
         var customDate = createFixedDate();
-        customDate.setMinutes((customDate.getMinutes() - customDate.getTimezoneOffset()) + 120);
         customDate.getTimezoneOffset = function () {
             return 120;
         };
 
-        dateFormat.asString('O.SSS.ss.mm.hh.dd.MM.yy', customDate).should.eql('-0200.005.30.31.16.11.01.10');
+        dateFormat.asString('O.SSS.ss.mm.hh.dd.MM.yy', customDate).should.eql('-0200.005.30.31.14.11.01.10');
     });
 });

package/test/parse-test.js

@@ -33,21 +33,19 @@ describe("dateFormat.parse", function() {
 
     it("should return the correct date if the string matches", function() {
       var testDate = new Date();
-      testDate.setFullYear(2018);
-      testDate.setMonth(8);
-      testDate.setDate(13);
-      testDate.setHours(18);
-      testDate.setMinutes(10);
-      testDate.setSeconds(12);
-      testDate.setMilliseconds(392);
-      testDate.getTimezoneOffset = function() {
-        return 600;
-      };
+      testDate.setUTCFullYear(2018);
+      testDate.setUTCMonth(8);
+      testDate.setUTCDate(13);
+      testDate.setUTCHours(18);
+      testDate.setUTCMinutes(10);
+      testDate.setUTCSeconds(12);
+      testDate.setUTCMilliseconds(392);
 
       dateFormat
-        .parse(pattern, "2018-09-13 08:10:12.392+1000")
+        .parse(pattern, "2018-09-14 04:10:12.392+1000")
         .getTime()
-        .should.eql(testDate.getTime());
+        .should.eql(testDate.getTime())
+        ;
     });
 
     it("should throw if the string does not match", function() {
@@ -65,7 +63,10 @@ describe("dateFormat.parse", function() {
       return testDate;
     };
 
-    function verifyDate(actual, expected) {
+    /**
+     * If there's no timezone in the format, then we verify against the local date
+     */
+    function verifyLocalDate(actual, expected) {
       actual.getFullYear().should.eql(expected.year || testDate.getFullYear());
       actual.getMonth().should.eql(expected.month || testDate.getMonth());
       actual.getDate().should.eql(expected.day || testDate.getDate());
@@ -77,19 +78,34 @@ describe("dateFormat.parse", function() {
         .should.eql(expected.milliseconds || testDate.getMilliseconds());
     }
 
+    /**
+     * If a timezone is specified, let's verify against the UTC time it is supposed to be
+     */
+    function verifyDate(actual, expected) {
+      actual.getUTCFullYear().should.eql(expected.year || testDate.getUTCFullYear());
+      actual.getUTCMonth().should.eql(expected.month || testDate.getUTCMonth());
+      actual.getUTCDate().should.eql(expected.day || testDate.getUTCDate());
+      actual.getUTCHours().should.eql(expected.hours || testDate.getUTCHours());
+      actual.getUTCMinutes().should.eql(expected.minutes || testDate.getUTCMinutes());
+      actual.getUTCSeconds().should.eql(expected.seconds || testDate.getUTCSeconds());
+      actual
+        .getMilliseconds()
+        .should.eql(expected.milliseconds || testDate.getMilliseconds());
+    }
+
     it("should return a date with missing values defaulting to current time", function() {
       var date = dateFormat.parse("yyyy-MM", "2015-09");
-      verifyDate(date, { year: 2015, month: 8 });
+      verifyLocalDate(date, { year: 2015, month: 8 });
     });
 
     it("should use a passed in date for missing values", function() {
-      var missingValueDate = new Date(2010, 1, 11, 10, 30, 12, 100);
+      var missingValueDate = new Date(2010, 1, 8, 22, 30, 12, 100);
       var date = dateFormat.parse("yyyy-MM", "2015-09", missingValueDate);
-      verifyDate(date, {
+      verifyLocalDate(date, {
         year: 2015,
         month: 8,
-        day: 11,
-        hours: 10,
+        day: 8,
+        hours: 22,
         minutes: 30,
         seconds: 12,
         milliseconds: 100
@@ -98,80 +114,107 @@ describe("dateFormat.parse", function() {
 
     it("should handle variations on the same pattern", function() {
       var date = dateFormat.parse("MM-yyyy", "09-2015");
-      verifyDate(date, { year: 2015, month: 8 });
+      verifyLocalDate(date, { year: 2015, month: 8 });
 
       date = dateFormat.parse("yyyy MM", "2015 09");
-      verifyDate(date, { year: 2015, month: 8 });
+      verifyLocalDate(date, { year: 2015, month: 8 });
 
       date = dateFormat.parse("MM, yyyy.", "09, 2015.");
-      verifyDate(date, { year: 2015, month: 8 });
+      verifyLocalDate(date, { year: 2015, month: 8 });
     });
 
-    it("should match all the date parts", function() {
-      var date = dateFormat.parse("dd", "21");
-      verifyDate(date, { day: 21 });
+    describe("should match all the date parts", function() {
+      it("works with dd", function() {
+        var date = dateFormat.parse("dd", "21");
+        verifyLocalDate(date, { day: 21 });
+      });
 
-      date = dateFormat.parse("hh", "12");
-      verifyDate(date, { hours: 12 });
+      it("works with hh", function() {
+        var date = dateFormat.parse("hh", "12");
+        verifyLocalDate(date, { hours: 12 });
+      });
 
-      date = dateFormat.parse("mm", "34");
-      verifyDate(date, { minutes: 34 });
+      it("works with mm", function() {
+        var date = dateFormat.parse("mm", "34");
+        verifyLocalDate(date, { minutes: 34 });
+      });
 
-      date = dateFormat.parse("ss", "59");
-      verifyDate(date, { seconds: 59 });
+      it("works with ss", function() {
+        var date = dateFormat.parse("ss", "59");
+        verifyLocalDate(date, { seconds: 59 });
+      });
 
-      date = dateFormat.parse("ss.SSS", "23.452");
-      verifyDate(date, { seconds: 23, milliseconds: 452 });
+      it("works with ss.SSS", function() {
+        var date = dateFormat.parse("ss.SSS", "23.452");
+        verifyLocalDate(date, { seconds: 23, milliseconds: 452 });
+      });
 
-      date = dateFormat.parse("hh:mm O", "05:23 +1000");
-      verifyDate(date, { hours: 15, minutes: 23 });
+      it("works with hh:mm O (+1000)", function() {
+        var date = dateFormat.parse("hh:mm O", "05:23 +1000");
+        verifyDate(date, { hours: 19, minutes: 23 });
+      });
 
-      date = dateFormat.parse("hh:mm O", "05:23 -200");
-      verifyDate(date, { hours: 3, minutes: 23 });
+      it("works with hh:mm O (-200)", function() {
+        var date = dateFormat.parse("hh:mm O", "05:23 -200");
+        verifyDate(date, { hours: 7, minutes: 23 });
+      });
 
-      date = dateFormat.parse("hh:mm O", "05:23 +0930");
-      verifyDate(date, { hours: 14, minutes: 53 });
+      it("works with hh:mm O (+0930)", function() {
+        var date = dateFormat.parse("hh:mm O", "05:23 +0930");
+        verifyDate(date, { hours: 19, minutes: 53 });
+      });
     });
   });
 
   describe("with a date formatted by this library", function() {
-    var testDate = new Date();
-    testDate.setUTCFullYear(2018);
-    testDate.setUTCMonth(8);
-    testDate.setUTCDate(13);
-    testDate.setUTCHours(18);
-    testDate.setUTCMinutes(10);
-    testDate.setUTCSeconds(12);
-    testDate.setUTCMilliseconds(392);
-
-    it("should format and then parse back to the same date", function() {
-      dateFormat
-        .parse(
-          dateFormat.ISO8601_WITH_TZ_OFFSET_FORMAT,
-          dateFormat(dateFormat.ISO8601_WITH_TZ_OFFSET_FORMAT, testDate)
-        )
-        .should.eql(testDate);
+    describe("should format and then parse back to the same date", function() {
+      function testDateInitWithUTC() {
+        var td = new Date();
+        td.setUTCFullYear(2018);
+        td.setUTCMonth(8);
+        td.setUTCDate(13);
+        td.setUTCHours(18);
+        td.setUTCMinutes(10);
+        td.setUTCSeconds(12);
+        td.setUTCMilliseconds(392);
+        return td;
+      }
+
+      it("works with ISO8601_WITH_TZ_OFFSET_FORMAT", function() {
+        // For this test case to work, the date object must be initialized with
+        // UTC timezone
+        var td = testDateInitWithUTC();
+        var d = dateFormat(dateFormat.ISO8601_WITH_TZ_OFFSET_FORMAT, td);
+        dateFormat.parse(dateFormat.ISO8601_WITH_TZ_OFFSET_FORMAT, d)
+          .should.eql(td);
+      });
 
-      dateFormat
-        .parse(
-          dateFormat.ISO8601_FORMAT,
-          dateFormat(dateFormat.ISO8601_FORMAT, testDate)
-        )
-        .should.eql(testDate);
+      it("works with ISO8601_FORMAT", function() {
+        var td = new Date();
+        var d = dateFormat(dateFormat.ISO8601_FORMAT, td);
+        var actual = dateFormat.parse(dateFormat.ISO8601_FORMAT, d);
+        actual.should.eql(td);
+      });
 
-      dateFormat
+      it("works with DATETIME_FORMAT", function() {
+        var testDate = new Date();
+        dateFormat
         .parse(
           dateFormat.DATETIME_FORMAT,
           dateFormat(dateFormat.DATETIME_FORMAT, testDate)
         )
         .should.eql(testDate);
+      });
 
-      dateFormat
+      it("works with ABSOLUTETIME_FORMAT", function() {
+        var testDate = new Date();
+        dateFormat
         .parse(
           dateFormat.ABSOLUTETIME_FORMAT,
           dateFormat(dateFormat.ABSOLUTETIME_FORMAT, testDate)
         )
         .should.eql(testDate);
+      });
     });
   });
 });