date-format 1.2.0 → 4.0.1

package/.eslintrc

@@ -1,24 +1,12 @@
 {
+  "extends": [
+    "eslint:recommended"
+  ],
   "env": {
     "node": true,
     "mocha": true
   },
   "plugins": [
-      "mocha",
-      "import"
-  ],
-  "rules": {
-    "comma-dangle": 0,
-    "indent": 2,
-    "func-names": 0,
-    "max-len": [1, 120, 2],
-    "no-use-before-define": 1,
-    "no-param-reassign": 0,
-    "strict": 0,
-    "import/no-extraneous-dependencies": ["error", {"devDependencies": ["test/*.js"]}],
-    "mocha/no-exclusive-tests": "error"
-  },
-  "parserOptions": {
-    "ecmaVersion": 5
-  }
+      "mocha"
+  ]
 }

package/.github/workflows/codeql-analysis.yml

@@ -0,0 +1,70 @@
+# For most projects, this workflow file will not need changing; you simply need
+# to commit it to your repository.
+#
+# You may wish to alter this file to override the set of languages analyzed,
+# or to provide custom queries or build logic.
+#
+# ******** NOTE ********
+# We have attempted to detect the languages in your repository. Please check
+# the `language` matrix defined below to confirm you have the correct set of
+# supported CodeQL languages.
+#
+name: "CodeQL"
+
+on:
+  push:
+    branches: [ master ]
+  pull_request:
+    # The branches below must be a subset of the branches above
+    branches: [ master ]
+  schedule:
+    - cron: '34 6 * * 1'
+
+jobs:
+  analyze:
+    name: Analyze
+    runs-on: ubuntu-latest
+    permissions:
+      actions: read
+      contents: read
+      security-events: write
+
+    strategy:
+      fail-fast: false
+      matrix:
+        language: [ 'javascript' ]
+        # CodeQL supports [ 'cpp', 'csharp', 'go', 'java', 'javascript', 'python', 'ruby' ]
+        # Learn more about CodeQL language support at https://git.io/codeql-language-support
+
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@v2
+
+    # Initializes the CodeQL tools for scanning.
+    - name: Initialize CodeQL
+      uses: github/codeql-action/init@v1
+      with:
+        languages: ${{ matrix.language }}
+        # If you wish to specify custom queries, you can do so here or in a config file.
+        # By default, queries listed here will override any specified in a config file.
+        # Prefix the list here with "+" to use these queries and those in the config file.
+        # queries: ./path/to/local/query, your-org/your-repo/queries@main
+
+    # Autobuild attempts to build any compiled languages  (C/C++, C#, or Java).
+    # If this step fails, then you should remove it and run the build manually (see below)
+    - name: Autobuild
+      uses: github/codeql-action/autobuild@v1
+
+    # ℹ️ Command-line programs to run using the OS shell.
+    # 📚 https://git.io/JvXDl
+
+    # ✏️ If the Autobuild fails above, remove it and uncomment the following three lines
+    #    and modify them (or add more) to build your code if your project
+    #    uses a compiled language
+
+    #- run: |
+    #   make bootstrap
+    #   make release
+
+    - name: Perform CodeQL Analysis
+      uses: github/codeql-action/analyze@v1

package/.github/workflows/node.js.yml

@@ -0,0 +1,31 @@
+# This workflow will do a clean install of node dependencies, cache/restore them, build the source code and run tests across different versions of node
+# For more information see: https://help.github.com/actions/language-and-framework-guides/using-nodejs-with-github-actions
+
+name: Node.js CI
+
+on:
+  push:
+    branches: [ master ]
+  pull_request:
+    branches: [ master ]
+
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+
+    strategy:
+      matrix:
+        node-version: [12.x, 14.x, 16.x]
+        # See supported Node.js release schedule at https://nodejs.org/en/about/releases/
+
+    steps:
+    - uses: actions/checkout@v2
+    - name: Use Node.js ${{ matrix.node-version }}
+      uses: actions/setup-node@v2
+      with:
+        node-version: ${{ matrix.node-version }}
+        cache: 'npm'
+    - run: npm ci
+    - run: npm run build --if-present
+    - run: npm test

package/.github/workflows/npm-publish.yml

@@ -0,0 +1,38 @@
+# This workflow will run tests using node and then publish a package to GitHub Packages when a milestone is closed
+# For more information see: https://help.github.com/actions/language-and-framework-guides/publishing-nodejs-packages
+
+name: Node.js Package
+
+on:
+  milestone:
+    types: [closed]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions/setup-node@v2
+        with:
+          node-version: 16
+      - run: npm ci
+      - run: npm test
+  
+  publish-npm:
+    needs: build
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions/setup-node@v2
+        with:
+          node-version: 16
+          registry-url: https://registry.npmjs.org/
+      - run: npm ci
+      - run: |
+          git config user.name github-actions
+          git config user.email github-actions@github.com
+      - run: npm version ${{ github.event.milestone.title }}
+      - run: git push && git push --tags
+      - run: npm publish
+        env:
+          NODE_AUTH_TOKEN: ${{secrets.npm_token}}

package/.travis.yml

@@ -1,7 +1,6 @@
 language: node_js
 sudo: false
 node_js:
-  - "7"
+  - "10"
+  - "8"
   - "6"
-  - "5"
-  - "4"

package/CHANGELOG.md

@@ -0,0 +1,16 @@
+# log4js-node changelog
+
+## 4.0.0
+
+- [Fix timezone format to include colon separator](https://github.com/nomiddlename/date-format/pull/27) - thanks [@peteriman](https://github.com/peteriman)
+  - [test: have a test case for timezone with colon](https://github.com/nomiddlename/date-format/pull/32) - thanks [@peteriman](https://github.com/peteriman)
+- [Docs: Updated README.md with more examples and expected output](https://github.com/nomiddlename/date-format/pull/33) - thanks [@peteriman](https://github.com/peteriman)
+- Updated dependencies
+  - [should-util from 1.0.0 to 1.0.1](https://github.com/nomiddlename/date-format/pull/31) 
+  - [eslint from 5.16.0 to 8.6.0 and mocha from 5.2.0 to 9.1.3](https://github.com/nomiddlename/date-format/pull/30) 
+  - [acorn from 6.2.0 to 6.4.2](https://github.com/nomiddlename/date-format/pull/29)
+  - [lodash from 4.17.14 to 4.17.21](https://github.com/nomiddlename/date-format/pull/26)
+
+## Previous versions
+
+Change information for older versions can be found by looking at the milestones in github.

package/README.md

@@ -10,20 +10,33 @@ npm install date-format
 usage
 =====
 
-```js
+Formatting dates as strings
+----
+
+```javascript
 var format = require('date-format');
-format.asString(); //defaults to ISO8601 format and current date.
-format.asString(new Date()); //defaults to ISO8601 format
-format.asString('hh:mm:ss.SSS', new Date()); //just the time
+format.asString(); // defaults to ISO8601 format and current date
+format.asString(new Date()); // defaults to ISO8601 format
+format.asString('hh:mm:ss.SSS', new Date()); // just the time
+format.asString(format.ISO8601_WITH_TZ_OFFSET_FORMAT, new Date()); // in ISO8601 with timezone
 ```
 
 or
 
-```js
+```javascript
 var format = require('date-format');
-format(); //defaults to ISO8601 format and current date.
-format(new Date());
-format('hh:mm:ss.SSS', new Date());
+format(); // defaults to ISO8601 format and current date
+format(new Date()); // defaults to ISO8601 format
+format('hh:mm:ss.SSS', new Date()); // just the time
+format(format.ISO8601_WITH_TZ_OFFSET_FORMAT, new Date()); // in ISO8601 with timezone
+```
+
+**output:**
+```javascript
+2017-03-14T14:10:20.391
+2017-03-14T14:10:20.391
+14:10:20.391
+2017-03-14T14:10:20.391+11:00
 ```
 
 Format string can be anything, but the following letters will be replaced (and leading zeroes added if necessary):
@@ -35,6 +48,24 @@ Format string can be anything, but the following letters will be replaced (and l
 * mm - `date.getMinutes()`
 * ss - `date.getSeconds()`
 * SSS - `date.getMilliseconds()`
-* O - timezone offset in +hm format
+* O - timezone offset in ±hh:mm format (note that time will still be local if displaying offset)
+
+Built-in formats:
+* `format.ISO8601_FORMAT` - `2017-03-14T14:10:20.391` (local time used)
+* `format.ISO8601_WITH_TZ_OFFSET_FORMAT` - `2017-03-14T14:10:20.391+11:00` (local + TZ used)
+* `format.DATETIME_FORMAT` - `14 03 2017 14:10:20.391` (local time used)
+* `format.ABSOLUTETIME_FORMAT` - `14:10:20.391` (local time used)
 
-That's it.
+Parsing strings as dates
+----
+The date format library has limited ability to parse strings into dates. It can convert strings created using date format patterns (as above), but if you're looking for anything more sophisticated than that you should probably look for a better library ([momentjs](https://momentjs.com) does pretty much everything).
+
+```javascript
+var format = require('date-format');
+// pass in the format of the string as first argument
+format.parse(format.ISO8601_FORMAT, '2017-03-14T14:10:20.391');
+format.parse(format.ISO8601_WITH_TZ_OFFSET_FORMAT, '2017-03-14T14:10:20.391+1100');
+format.parse(format.ISO8601_WITH_TZ_OFFSET_FORMAT, '2017-03-14T14:10:20.391+11:00');
+format.parse(format.ISO8601_WITH_TZ_OFFSET_FORMAT, '2017-03-14T03:10:20.391Z');
+// returns Date
+```

package/lib/index.js

@@ -1,15 +1,15 @@
-'use strict';
+"use strict";
 
 function padWithZeros(vNumber, width) {
-    var numAsString = vNumber.toString();
-    while (numAsString.length < width) {
-        numAsString = '0' + numAsString;
-    }
-    return numAsString;
+  var numAsString = vNumber.toString();
+  while (numAsString.length < width) {
+    numAsString = "0" + numAsString;
+  }
+  return numAsString;
 }
 
 function addZero(vNumber) {
-    return padWithZeros(vNumber, 2);
+  return padWithZeros(vNumber, 2);
 }
 
 /**
@@ -18,46 +18,42 @@ function addZero(vNumber) {
  * @private
  */
 function offset(timezoneOffset) {
-  // Difference to Greenwich time (GMT) in hours
-    var os = Math.abs(timezoneOffset);
-    var h = String(Math.floor(os / 60));
-    var m = String(os % 60);
-    if (h.length === 1) {
-        h = '0' + h;
-    }
-    if (m.length === 1) {
-        m = '0' + m;
-    }
-    return timezoneOffset < 0 ? '+' + h + m : '-' + h + m;
+  var os = Math.abs(timezoneOffset);
+  var h = String(Math.floor(os / 60));
+  var m = String(os % 60);
+  if (h.length === 1) {
+    h = "0" + h;
+  }
+  if (m.length === 1) {
+    m = "0" + m;
+  }
+  return timezoneOffset === 0 ? "Z" : (timezoneOffset < 0 ? "+" : "-") + h + ":" + m;
 }
 
-function asString(format, date, timezoneOffset) {
-    if (typeof format !== 'string') {
-        timezoneOffset = date;
-        date = format;
-        format = module.exports.ISO8601_FORMAT;
-    }
-    if (!date) {
-        date = new Date();
-    }
-  // make the date independent of the system timezone by working with UTC
-    if (timezoneOffset === undefined) {
-        timezoneOffset = date.getTimezoneOffset();
-    }
+function asString(format, date) {
+  if (typeof format !== "string") {
+    date = format;
+    format = module.exports.ISO8601_FORMAT;
+  }
+  if (!date) {
+    date = module.exports.now();
+  }
 
-    date.setUTCMinutes(date.getUTCMinutes() - timezoneOffset);
-    var vDay = addZero(date.getUTCDate());
-    var vMonth = addZero(date.getUTCMonth() + 1);
-    var vYearLong = addZero(date.getUTCFullYear());
-    var vYearShort = addZero(date.getUTCFullYear().toString().substring(2, 4));
-    var vYear = (format.indexOf('yyyy') > -1 ? vYearLong : vYearShort);
-    var vHour = addZero(date.getUTCHours());
-    var vMinute = addZero(date.getUTCMinutes());
-    var vSecond = addZero(date.getUTCSeconds());
-    var vMillisecond = padWithZeros(date.getUTCMilliseconds(), 3);
-    var vTimeZone = offset(timezoneOffset);
-    date.setUTCMinutes(date.getUTCMinutes() + timezoneOffset);
-    var formatted = format
+  // 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(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(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)
     .replace(/MM/g, vMonth)
     .replace(/y{1,4}/g, vYear)
@@ -66,12 +62,161 @@ function asString(format, date, timezoneOffset) {
     .replace(/ss/g, vSecond)
     .replace(/SSS/g, vMillisecond)
     .replace(/O/g, vTimeZone);
-    return formatted;
+  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) {
+        setDatePart(date, 'FullYear', value, local);
+      }
+    },
+    {
+      pattern: /MM/,
+      regexp: "\\d{1,2}",
+      fn: function(date, value) {
+        setDatePart(date, 'Month', (value - 1), local);
+      }
+    },
+    {
+      pattern: /dd/,
+      regexp: "\\d{1,2}",
+      fn: function(date, value) {
+        setDatePart(date, 'Date', value, local);
+      }
+    },
+    {
+      pattern: /hh/,
+      regexp: "\\d{1,2}",
+      fn: function(date, value) {
+        setDatePart(date, 'Hours', value, local);
+      }
+    },
+    {
+      pattern: /mm/,
+      regexp: "\\d\\d",
+      fn: function(date, value) {
+        setDatePart(date, 'Minutes', value, local);
+      }
+    },
+    {
+      pattern: /ss/,
+      regexp: "\\d\\d",
+      fn: function(date, value) {
+        setDatePart(date, 'Seconds', value, local);
+      }
+    },
+    {
+      pattern: /SSS/,
+      regexp: "\\d\\d\\d",
+      fn: function(date, value) {
+        setDatePart(date, 'Milliseconds', value, local);
+      }
+    },
+    {
+      pattern: /O/,
+      regexp: "[+-]\\d{1,2}:?\\d{2}?|Z",
+      fn: function(date, value) {
+        if (value === "Z") {
+          value = 0;
+        }
+        else {
+          value = value.replace(":", "");
+        }
+        var offset = Math.abs(value);
+        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);
+      }
+    }
+  ];
+
+  var parsedPattern = matchers.reduce(
+    function(p, m) {
+      if (m.pattern.test(p.regexp)) {
+        m.index = p.regexp.match(m.pattern).index;
+        p.regexp = p.regexp.replace(m.pattern, "(" + m.regexp + ")");
+      } else {
+        m.index = -1;
+      }
+      return p;
+    },
+    { regexp: pattern, index: [] }
+  );
+
+  var dateFns = matchers.filter(function(m) {
+    return m.index > -1;
+  });
+  dateFns.sort(function(a, b) {
+    return a.index - b.index;
+  });
+
+  var matcher = new RegExp(parsedPattern.regexp);
+  var matches = matcher.exec(str);
+  if (matches) {
+    var date = missingValuesDate || module.exports.now();
+    dateFns.forEach(function(f, i) {
+      f.fn(date, matches[i + 1]);
+    });
+
+    return date;
+  }
+
+  throw new Error(
+    "String '" + str + "' could not be parsed as '" + pattern + "'"
+  );
+}
+
+function parse(pattern, str, missingValuesDate) {
+  if (!pattern) {
+    throw new Error("pattern must be supplied");
+  }
+
+  return extractDateParts(pattern, str, missingValuesDate);
+}
+
+/**
+ * Used for testing - replace this function with a fixed date.
+ */
+function now() {
+  return new Date();
 }
 
 module.exports = asString;
 module.exports.asString = asString;
-module.exports.ISO8601_FORMAT = 'yyyy-MM-ddThh:mm:ss.SSS';
-module.exports.ISO8601_WITH_TZ_OFFSET_FORMAT = 'yyyy-MM-ddThh:mm:ss.SSSO';
-module.exports.DATETIME_FORMAT = 'dd MM yyyy hh:mm:ss.SSS';
-module.exports.ABSOLUTETIME_FORMAT = 'hh:mm:ss.SSS';
+module.exports.parse = parse;
+module.exports.now = now;
+module.exports.ISO8601_FORMAT = "yyyy-MM-ddThh:mm:ss.SSS";
+module.exports.ISO8601_WITH_TZ_OFFSET_FORMAT = "yyyy-MM-ddThh:mm:ss.SSSO";
+module.exports.DATETIME_FORMAT = "dd MM yyyy hh:mm:ss.SSS";
+module.exports.ABSOLUTETIME_FORMAT = "hh:mm:ss.SSS";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "date-format",
-  "version": "1.2.0",
+  "version": "4.0.1",
   "description": "Formatting Date objects as strings since 2013",
   "main": "lib/index.js",
   "repository": {
@@ -25,10 +25,9 @@
   "readmeFilename": "README.md",
   "gitHead": "bf59015ab6c9e86454b179374f29debbdb403522",
   "devDependencies": {
-    "eslint": "^3.12.0",
-    "eslint-plugin-import": "^2.2.0",
-    "eslint-plugin-mocha": "^4.8.0",
-    "mocha": "^3.2.0",
-    "should": "^11.1.2"
+    "eslint": "^8.6.0",
+    "eslint-plugin-mocha": "^5.3.0",
+    "mocha": "^9.1.3",
+    "should": "^13.2.3"
   }
 }

package/test/date_format-test.js

@@ -29,22 +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 local time
         dateFormat.asString(dateFormat.ISO8601_WITH_TZ_OFFSET_FORMAT, tzDate)
-          .should.eql('2010-01-11T14:31:30.005+1100');
+            .should.eql('2010-01-11T14:31:30.005+11:00');
 
         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-11T14:31:30.005-0200');
+            .should.eql('2010-01-11T14:31:30.005-02:00');
     });
 
     it('should provide a just-the-time format', function() {
@@ -53,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.14.11.01.10');
+        dateFormat.asString('O.SSS.ss.mm.hh.dd.MM.yy', customDate).should.eql('-02:00.005.30.31.14.11.01.10');
     });
 });

package/test/parse-test.js

@@ -0,0 +1,220 @@
+"use strict";
+
+require("should");
+var dateFormat = require("../lib");
+
+describe("dateFormat.parse", function() {
+  it("should require a pattern", function() {
+    (function() {
+      dateFormat.parse();
+    }.should.throw(/pattern must be supplied/));
+    (function() {
+      dateFormat.parse(null);
+    }.should.throw(/pattern must be supplied/));
+    (function() {
+      dateFormat.parse("");
+    }.should.throw(/pattern must be supplied/));
+  });
+
+  describe("with a pattern that has no replacements", function() {
+    it("should return a new date when the string matches", function() {
+      dateFormat.parse("cheese", "cheese").should.be.a.Date();
+    });
+
+    it("should throw if the string does not match", function() {
+      (function() {
+        dateFormat.parse("cheese", "biscuits");
+      }.should.throw(/String 'biscuits' could not be parsed as 'cheese'/));
+    });
+  });
+
+  describe("with a full pattern", function() {
+    var pattern = "yyyy-MM-dd hh:mm:ss.SSSO";
+
+    it("should return the correct date if the string matches", 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);
+
+      dateFormat
+        .parse(pattern, "2018-09-14 04:10:12.392+1000")
+        .getTime()
+        .should.eql(testDate.getTime())
+        ;
+    });
+
+    it("should throw if the string does not match", function() {
+      (function() {
+        dateFormat.parse(pattern, "biscuits");
+      }.should.throw(
+        /String 'biscuits' could not be parsed as 'yyyy-MM-dd hh:mm:ss.SSSO'/
+      ));
+    });
+  });
+
+  describe("with a partial pattern", function() {
+    var testDate = new Date();
+    dateFormat.now = function() {
+      return testDate;
+    };
+
+    /**
+     * 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());
+      actual.getHours().should.eql(expected.hours || testDate.getHours());
+      actual.getMinutes().should.eql(expected.minutes || testDate.getMinutes());
+      actual.getSeconds().should.eql(expected.seconds || testDate.getSeconds());
+      actual
+        .getMilliseconds()
+        .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");
+      verifyLocalDate(date, { year: 2015, month: 8 });
+    });
+
+    it("should use a passed in date for missing values", function() {
+      var missingValueDate = new Date(2010, 1, 8, 22, 30, 12, 100);
+      var date = dateFormat.parse("yyyy-MM", "2015-09", missingValueDate);
+      verifyLocalDate(date, {
+        year: 2015,
+        month: 8,
+        day: 8,
+        hours: 22,
+        minutes: 30,
+        seconds: 12,
+        milliseconds: 100
+      });
+    });
+
+    it("should handle variations on the same pattern", function() {
+      var date = dateFormat.parse("MM-yyyy", "09-2015");
+      verifyLocalDate(date, { year: 2015, month: 8 });
+
+      date = dateFormat.parse("yyyy MM", "2015 09");
+      verifyLocalDate(date, { year: 2015, month: 8 });
+
+      date = dateFormat.parse("MM, yyyy.", "09, 2015.");
+      verifyLocalDate(date, { year: 2015, month: 8 });
+    });
+
+    describe("should match all the date parts", function() {
+      it("works with dd", function() {
+        var date = dateFormat.parse("dd", "21");
+        verifyLocalDate(date, { day: 21 });
+      });
+
+      it("works with hh", function() {
+        var date = dateFormat.parse("hh", "12");
+        verifyLocalDate(date, { hours: 12 });
+      });
+
+      it("works with mm", function() {
+        var date = dateFormat.parse("mm", "34");
+        verifyLocalDate(date, { minutes: 34 });
+      });
+
+      it("works with ss", function() {
+        var date = dateFormat.parse("ss", "59");
+        verifyLocalDate(date, { seconds: 59 });
+      });
+
+      it("works with ss.SSS", function() {
+        var date = dateFormat.parse("ss.SSS", "23.452");
+        verifyLocalDate(date, { seconds: 23, milliseconds: 452 });
+      });
+
+      it("works with hh:mm O (+1000)", function() {
+        var date = dateFormat.parse("hh:mm O", "05:23 +1000");
+        verifyDate(date, { hours: 19, 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 });
+      });
+
+      it("works with hh:mm O (+09:30)", function() {
+        var date = dateFormat.parse("hh:mm O", "05:23 +09:30");
+        verifyDate(date, { hours: 19, minutes: 53 });
+      });
+    });
+  });
+
+  describe("with a date formatted by this library", function() {
+    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);
+      });
+
+      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);
+      });
+
+      it("works with DATETIME_FORMAT", function() {
+        var testDate = new Date();
+        dateFormat
+        .parse(
+          dateFormat.DATETIME_FORMAT,
+          dateFormat(dateFormat.DATETIME_FORMAT, testDate)
+        )
+        .should.eql(testDate);
+      });
+
+      it("works with ABSOLUTETIME_FORMAT", function() {
+        var testDate = new Date();
+        dateFormat
+        .parse(
+          dateFormat.ABSOLUTETIME_FORMAT,
+          dateFormat(dateFormat.ABSOLUTETIME_FORMAT, testDate)
+        )
+        .should.eql(testDate);
+      });
+    });
+  });
+});

package/.npmignore

@@ -1,15 +0,0 @@
-lib-cov
-*.seed
-*.log
-*.csv
-*.dat
-*.out
-*.pid
-*.gz
-
-pids
-logs
-results
-
-npm-debug.log
-node_modules