chrono-node 1.3.2 → 1.3.11

package/package.json

@@ -6,8 +6,12 @@
     "type": "git",
     "url": "https://github.com/berryboy/chrono.git"
   },
+  "jest": {
+    "verbose": true,
+    "testURL": "http://localhost/"
+  },
   "license": "MIT",
-  "version": "1.3.2",
+  "version": "1.3.11",
   "directories": {
     "source": "./src",
     "test": "./test"
@@ -15,27 +19,19 @@
   "main": "./src/chrono",
   "devDependencies": {
     "browserify": "^14.3.0",
-    "coveralls": "^2.11.2",
-    "istanbul": "^0.4.5",
-    "karma": "~1.7.0",
-    "karma-browserify": "^5.1.1",
-    "karma-chrome-launcher": "~2.1.1",
-    "karma-firefox-launcher": "~1.0.1",
-    "karma-qunit": "^1.2.1",
-    "minifyify": "^7.0.6",
-    "qunit": "^1.0.0",
-    "watchify": "^3.9.0"
+    "coveralls": "^3.0.2",
+    "jest": "^22.0.4",
+    "minifyify": "^7.0.6"
   },
   "scripts": {
     "make-bundle": "browserify src/chrono.js -d --s chrono -o chrono.js",
     "make-minify": "browserify src/chrono.js -d --s chrono -d -p [minifyify --output chrono.map.json] -o chrono.min.js",
     "make": "npm run make-bundle & npm run make-minify",
-    "watch": "watchify src/chrono.js -d --s chrono -o chrono.js",
-    "karma": "karma start",
-    "test": "qunit -l '{summary:true, tests: true}' -c chrono:src/chrono.js -p src -t test/*.js --cov --timeout 10000",
+    "watch": "jest --watch",
+    "test": "jest --coverage && npm audit --audit-level high",
     "coveralls": "npm run test && cat coverage/lcov.info | coveralls"
   },
   "dependencies": {
-    "moment": "^2.10.3"
+    "moment": "2.21.0"
   }
 }

package/src/chrono.js

@@ -14,8 +14,6 @@ exports.ParsedComponents = require('./result').ParsedComponents;
 var Chrono = function(option) {
 
     option = option || exports.options.casualOption();
-
-    this.option = option;
     this.parsers = new Object(option.parsers);
     this.refiners = new Object(option.refiners);
 };
@@ -25,7 +23,8 @@ Chrono.prototype.parse = function(text, refDate, opt) {
 
     refDate = refDate || new Date();
     opt = opt || {};
-
+    opt.forwardDate = opt.forwardDate || opt.forwardDate;
+    
     var allResults = [];
 
     this.parsers.forEach(function (parser) {

package/src/options.js

@@ -56,7 +56,7 @@ exports.commonPostProcessing = function() {
 exports.strictOption = function () {
     var strictConfig = {
         strict: true
-    }
+    };
 
     return exports.mergeOptions([
         exports.en(strictConfig),
@@ -129,6 +129,7 @@ exports.en = function(config) {
             new parser.ENSlashDateFormatStartWithYearParser(config),
             new parser.ENSlashMonthFormatParser(config),
             new parser.ENTimeAgoFormatParser(config),
+            new parser.ENTimeLaterFormatParser(config),
             new parser.ENTimeExpressionParser(config)
         ],
         refiners: [
@@ -148,7 +149,7 @@ exports.en.casual = function(config) {
     config.strict = false;
     var option = exports.en(config);
 
-    // EN
+    // en
     option.parsers.unshift(new parser.ENCasualDateParser());
     option.parsers.unshift(new parser.ENCasualTimeParser());
     option.parsers.unshift(new parser.ENWeekdayParser());

package/src/parsers/{DE → de}/DEWeekdayParser.js

@@ -60,17 +60,17 @@ exports.Parser = function DEWeekdayParser() {
         } else if (/n(?:ä|ae)chste/.test(norm)) {
             startMoment.day(offset + 7);
         } else if (/diese/.test(norm)) {
-            if ( opt.forwardDatesOnly && refOffset > offset ) {
+            if ( opt.forwardDate && refOffset > offset ) {
                 startMoment.day(offset + 7);
             } else {
                 startMoment.day(offset);
             }
         } else {
-            if ( opt.forwardDatesOnly && refOffset > offset ) {
+            if ( opt.forwardDate && refOffset > offset ) {
                 startMoment.day(offset + 7);
-            } else if (!opt.forwardDatesOnly && Math.abs(offset - 7 - refOffset) < Math.abs(offset - refOffset)) {
+            } else if (!opt.forwardDate && Math.abs(offset - 7 - refOffset) < Math.abs(offset - refOffset)) {
                 startMoment.day(offset - 7);
-            } else if (!opt.forwardDatesOnly && Math.abs(offset + 7 - refOffset) < Math.abs(offset - refOffset)) {
+            } else if (!opt.forwardDate && Math.abs(offset + 7 - refOffset) < Math.abs(offset - refOffset)) {
                 startMoment.day(offset + 7);
             } else {
                 startMoment.day(offset);

package/src/parsers/{EN → en}/ENCasualDateParser.js

@@ -54,10 +54,10 @@ exports.Parser = function ENCasualDateParser(){
 
         } else if (lowerText.match("now")) {
 
-          result.start.imply('hour', refMoment.hour());
-          result.start.imply('minute', refMoment.minute());
-          result.start.imply('second', refMoment.second());
-          result.start.imply('millisecond', refMoment.millisecond());
+          result.start.assign('hour', refMoment.hour());
+          result.start.assign('minute', refMoment.minute());
+          result.start.assign('second', refMoment.second());
+          result.start.assign('millisecond', refMoment.millisecond());
 
         }
 

package/src/parsers/en/ENCasualTimeParser.js

@@ -0,0 +1,60 @@
+/*
+
+
+*/
+
+var moment = require('moment');
+var Parser = require('../parser').Parser;
+var ParsedResult = require('../../result').ParsedResult;
+
+var PATTERN = /(\W|^)((this)?\s*(morning|afternoon|evening|noon|night))/i;
+
+var TIME_MATCH = 4;
+
+exports.Parser = function ENCasualTimeParser(){
+
+    Parser.apply(this, arguments);
+
+
+    this.pattern = function() { return PATTERN; }
+
+    this.extract = function(text, ref, match, opt){
+
+        var text = match[0].substr(match[1].length);
+        var index = match.index + match[1].length;
+        var result = new ParsedResult({
+            index: index,
+            text: text,
+            ref: ref,
+        });
+
+        if(!match[TIME_MATCH]) TIME_MATCH = 3;
+        
+        switch (match[TIME_MATCH].toLowerCase()) {
+
+            case 'afternoon':
+                result.start.imply('meridiem', 1);
+                result.start.imply('hour', 15);
+                break;
+
+            case 'evening':
+            case 'night':
+                result.start.imply('meridiem', 1);
+                result.start.imply('hour', 20);
+                break;
+
+            case 'morning':
+                result.start.imply('meridiem', 0);
+                result.start.imply('hour', 6);
+                break;
+
+            case 'noon':
+                result.start.imply('meridiem', 0);
+                result.start.imply('hour', 12);
+                break;
+        }
+        
+        result.tags['ENCasualTimeParser'] = true;
+        return result;
+    };
+};

package/src/parsers/{EN → en}/ENDeadlineFormatParser.js

@@ -67,9 +67,9 @@ exports.Parser = function ENDeadlineFormatParser(){
                 date.add(num, 'year');
             }
 
-            result.start.assign('year', date.year());
-            result.start.assign('month', date.month() + 1);
-            result.start.assign('day', date.date());
+            result.start.imply('year', date.year());
+            result.start.imply('month', date.month() + 1);
+            result.start.imply('day', date.date());
             return result;
         }
 
@@ -89,9 +89,9 @@ exports.Parser = function ENDeadlineFormatParser(){
         result.start.imply('year', date.year());
         result.start.imply('month', date.month() + 1);
         result.start.imply('day', date.date());
-        result.start.assign('hour', date.hour());
-        result.start.assign('minute', date.minute());
-        result.start.assign('second', date.second());
+        result.start.imply('hour', date.hour());
+        result.start.imply('minute', date.minute());
+        result.start.imply('second', date.second());
         result.tags['ENDeadlineFormatParser'] = true;
         return result;
     };

package/src/parsers/{EN → en}/ENMonthNameLittleEndianParser.js

@@ -16,11 +16,15 @@ var PATTERN = new RegExp('(\\W|^)' +
         '(?:\\s*' +
             '(?:to|\\-|\\–|until|through|till|\\s)\\s*' +
             '(([0-9]{1,2})(?:st|nd|rd|th)?|' + util.ORDINAL_WORDS_PATTERN + ')' +
-        ')?\\s*(?:of)?\\s*' +
-        '(Jan(?:uary|\\.)?|Feb(?:ruary|\\.)?|Mar(?:ch|\\.)?|Apr(?:il|\\.)?|May|Jun(?:e|\\.)?|Jul(?:y|\\.)?|Aug(?:ust|\\.)?|Sep(?:tember|\\.)?|Oct(?:ober|\\.)?|Nov(?:ember|\\.)?|Dec(?:ember|\\.)?)' +
+        ')?' + 
+        '(?:-|\/|\\s*(?:of)?\\s*)' +
+        '(' + util.MONTH_PATTERN + ')' +
         '(?:' +
-            ',?\\s*([0-9]{1,4}(?![^\\s]\\d))' +
-            '(\\s*(?:BE|AD|BC))?' +
+            '(?:-|\/|,?\\s*)' +
+            '((?:' + 
+                '[1-9][0-9]{0,3}\\s*(?:BE|AD|BC)|' +
+                '[1-2][0-9]{3}' + 
+            ')(?![^\\s]\\d))' +
         ')?' +
         '(?=\\W|$)', 'i'
     );
@@ -32,7 +36,6 @@ var DATE_TO_GROUP = 5;
 var DATE_TO_NUM_GROUP = 6;
 var MONTH_NAME_GROUP = 7;
 var YEAR_GROUP = 8;
-var YEAR_BE_GROUP = 9;
 
 exports.Parser = function ENMonthNameLittleEndianParser(){
     Parser.apply(this, arguments);
@@ -57,26 +60,23 @@ exports.Parser = function ENMonthNameLittleEndianParser(){
         var year = null;
         if (match[YEAR_GROUP]) {
             year = match[YEAR_GROUP];
-            year = parseInt(year);
-
-            if(match[YEAR_BE_GROUP]){
-
-                if (/BE/i.test(match[YEAR_BE_GROUP])) {
-                    // Buddhist Era
-                    year = year - 543;
-                } else if (/BC/i.test(match[YEAR_BE_GROUP])) {
-                    // Before Christ
-                    year = -year;
+            
+            if (/BE/i.test(year)) {
+                // Buddhist Era
+                year = year.replace(/BE/i, '');
+                year = parseInt(year) - 543;
+            } else if (/BC/i.test(year)){
+                // Before Christ
+                year = year.replace(/BC/i, '');
+                year = -parseInt(year);
+            } else if (/AD/i.test(year)){
+                year = year.replace(/AD/i, '');
+                year = parseInt(year);
+            } else {
+                year = parseInt(year);
+                if (year < 100){
+                    year = year + 2000;
                 }
-
-            } else if (year < 10) {
-
-                // require single digit years to always have BC/AD
-                return null;
-
-            } else if (year < 100){
-
-                year = year + 2000;
             }
         }
 

package/src/parsers/{EN → en}/ENMonthNameMiddleEndianParser.js

@@ -25,15 +25,16 @@ var PATTERN = new RegExp('(\\W|^)' +
         '(?:on\\s*?)?' +
         '(Sunday|Monday|Tuesday|Wednesday|Thursday|Friday|Saturday|Sun\\.?|Mon\\.?|Tue\\.?|Wed\\.?|Thu\\.?|Fri\\.?|Sat\\.?)' +
     '\\s*,?\\s*)?' +
-    '(Jan\\.?|January|Feb\\.?|February|Mar\\.?|March|Apr\\.?|April|May\\.?|Jun\\.?|June|Jul\\.?|July|Aug\\.?|August|Sep\\.?|Sept\\.?|September|Oct\\.?|October|Nov\\.?|November|Dec\\.?|December)' +
-    '\\s*' +
-    '(([0-9]{1,2})(?:st|nd|rd|th)?|' + util.ORDINAL_WORDS_PATTERN +')\\s*' +
+    '(' + util.MONTH_PATTERN + ')' +
+    '(?:-|\/|\\s*,?\\s*)' +
+    '(([0-9]{1,2})(?:st|nd|rd|th)?|' + util.ORDINAL_WORDS_PATTERN +')(?!\\s*(?:am|pm))\\s*' + '' + 
     '(?:' +
         '(?:to|\\-)\\s*' +
         '(([0-9]{1,2})(?:st|nd|rd|th)?| ' + util.ORDINAL_WORDS_PATTERN + ')\\s*' +
     ')?' +
     '(?:' +
-        '\\s*,?\\s*(?:([0-9]{4})\\s*(BE|AD|BC)?|([0-9]{1,4})\\s*(AD|BC))\\s*' +
+        '(?:-|\/|\\s*,?\\s*)' +
+        '(?:([0-9]{4})\\s*(BE|AD|BC)?|([0-9]{1,4})\\s*(AD|BC))\\s*' +
     ')?' +
     '(?=\\W|$)(?!\\:\\d)', 'i');
 

package/src/parsers/{EN → en}/ENMonthNameParser.js

@@ -15,7 +15,7 @@ var ParsedResult = require('../../result').ParsedResult;
 var util  = require('../../utils/EN');
 
 var PATTERN = new RegExp('(^|\\D\\s+|[^\\w\\s])' +
-    '(Jan\\.?|January|Feb\\.?|February|Mar\\.?|March|Apr\\.?|April|May\\.?|Jun\\.?|June|Jul\\.?|July|Aug\\.?|August|Sep\\.?|Sept\\.?|September|Oct\\.?|October|Nov\\.?|November|Dec\\.?|December)' + 
+    '('+ util.MONTH_PATTERN +')' + 
     '\\s*' +
     '(?:' +
         '[,-]?\\s*([0-9]{4})(\\s*BE|AD|BC)?' +

package/src/parsers/{EN → en}/ENRelativeDateFormatParser.js

@@ -9,7 +9,7 @@ var ParsedResult = require('../../result').ParsedResult;
 var util  = require('../../utils/EN');
 
 var PATTERN = new RegExp('(\\W|^)' +
-    '(next|last|past)\\s*' +
+    '(this|next|last|past)\\s*' +
     '('+ util.INTEGER_WORDS_PATTERN + '|[0-9]+|few|half(?:\\s*an?)?)?\\s*' +
     '(seconds?|min(?:ute)?s?|hours?|days?|weeks?|months?|years?)(?=\\s*)' +
     '(?=\\W|$)', 'i'
@@ -52,8 +52,46 @@ exports.Parser = function ENRelativeDateFormatParser(){
         }
 
         num *= modifier;
-
         var date = moment(ref);
+
+        if (match[MODIFIER_WORD_GROUP].toLowerCase().match(/^this/)) {
+
+            if (match[MULTIPLIER_WORD_GROUP]) {
+                return null;
+            }
+
+            if (match[RELATIVE_WORD_GROUP].match(/day|week|month|year/i)) {
+                
+                // This week
+                if (match[RELATIVE_WORD_GROUP].match(/week/i)) {
+                    date.add(-date.get('d'), 'd');
+                    result.start.imply('day', date.date());
+                    result.start.imply('month', date.month() + 1);
+                    result.start.imply('year', date.year());
+                } 
+                
+                // This month
+                else if (match[RELATIVE_WORD_GROUP].match(/month/i)) {
+                    date.add(-date.date() + 1, 'd');
+                    result.start.imply('day', date.date());
+                    result.start.assign('year', date.year());
+                    result.start.assign('month', date.month() + 1);
+                } 
+
+                // This year
+                else if (match[RELATIVE_WORD_GROUP].match(/year/i)) {
+                    date.add(-date.date() + 1, 'd');
+                    date.add(-date.month(), 'month');
+
+                    result.start.imply('day', date.date());
+                    result.start.imply('month', date.month() + 1);
+                    result.start.assign('year', date.year());
+                } 
+
+                return result;
+            }
+        }
+        
         if (match[RELATIVE_WORD_GROUP].match(/day|week|month|year/i)) {
 
             if (match[RELATIVE_WORD_GROUP].match(/day/i)) {

package/src/parsers/{EN → en}/ENSlashDateFormatParser.js

@@ -116,7 +116,11 @@ exports.Parser = function ENSlashDateFormatParser(config) {
 
         result.start.assign('day', day);
         result.start.assign('month', month);
-        result.start.assign('year', year);
+        if (match[YEAR_GROUP]) {
+            result.start.assign('year', year);
+        } else {
+            result.start.imply('year', year);
+        }
 
         //Day of week
         if(match[WEEKDAY_GROUP]) {

package/src/parsers/{EN → en}/ENSlashDateFormatStartWithYearParser.js

@@ -8,9 +8,12 @@
 var moment = require('moment');
 var Parser = require('../parser').Parser;
 var ParsedResult = require('../../result').ParsedResult;
+var util  = require('../../utils/EN');
 
 var PATTERN = new RegExp('(\\W|^)' 
-            + '([0-9]{4})[\\-\\.\\/]([0-9]{1,2})[\\-\\.\\/]([0-9]{1,2})'
+            + '([0-9]{4})[\\-\\.\\/]'
+            + '((?:' + util.MONTH_PATTERN + '|[0-9]{1,2}))[\\-\\.\\/]'
+            + '([0-9]{1,2})'
             + '(?=\\W|$)', 'i');
 
 var YEAR_NUMBER_GROUP = 2;
@@ -33,8 +36,11 @@ exports.Parser = function ENSlashDateFormatStartWithYearParser(){
             ref: ref,
         })
         
+        var month = match[MONTH_NUMBER_GROUP].toLowerCase();
+        month = util.MONTH_OFFSET[month] | month;
+
         result.start.assign('year', parseInt(match[YEAR_NUMBER_GROUP]));
-        result.start.assign('month', parseInt(match[MONTH_NUMBER_GROUP]));
+        result.start.assign('month', parseInt(month));
         result.start.assign('day', parseInt(match[DATE_NUMBER_GROUP]));
 
         if (moment(result.start.get('month')) > 12 || moment(result.start.get('month')) < 1 ||

package/src/parsers/en/ENTimeAgoFormatParser.js

@@ -0,0 +1,69 @@
+var moment = require('moment');
+var Parser = require('../parser').Parser;
+var ParsedResult = require('../../result').ParsedResult;
+var util  = require('../../utils/EN');
+
+var PATTERN = new RegExp('' +
+    '(\\W|^)' +
+    '(?:within\\s*)?' +
+    '(' + util.TIME_UNIT_PATTERN + ')' +
+    '(?:ago|before|earlier)(?=(?:\\W|$))', 'i');
+
+var STRICT_PATTERN = new RegExp('' +
+    '(\\W|^)' +
+    '(?:within\\s*)?' +
+    '(' + util.TIME_UNIT_STRICT_PATTERN + ')' +
+    'ago(?=(?:\\W|$))', 'i');
+
+exports.Parser = function ENTimeAgoFormatParser(){
+    Parser.apply(this, arguments);
+
+    this.pattern = function() {
+        return this.isStrictMode()? STRICT_PATTERN : PATTERN;
+    };
+
+    this.extract = function(text, ref, match, opt){
+
+        if (match.index > 0 && text[match.index-1].match(/\w/)) return null;
+
+        var text = match[0];
+        text  = match[0].substr(match[1].length, match[0].length - match[1].length);
+        var index = match.index + match[1].length;
+
+        var result = new ParsedResult({
+            index: index,
+            text: text,
+            ref: ref
+        });
+
+        var fragments = util.extractDateTimeUnitFragments(match[2]);
+        var date = moment(ref);
+
+        for (var key in fragments) {
+            date.add(-fragments[key], key);
+        }
+
+        if (fragments['hour'] > 0 || fragments['minute'] > 0 || fragments['second'] > 0) {
+            result.start.assign('hour', date.hour());
+            result.start.assign('minute', date.minute());
+            result.start.assign('second', date.second());
+            result.tags['ENTimeAgoFormatParser'] = true;
+        } 
+        
+        if (fragments['d'] > 0 || fragments['month'] > 0 || fragments['year'] > 0) {
+            result.start.assign('day', date.date());
+            result.start.assign('month', date.month() + 1);
+            result.start.assign('year', date.year());
+        } else {
+            if (fragments['week'] > 0) {
+                result.start.imply('weekday', date.day());
+            }
+
+            result.start.imply('day', date.date());
+            result.start.imply('month', date.month() + 1);
+            result.start.imply('year', date.year());
+        }
+
+        return result;
+    };
+}

package/src/parsers/{EN → en}/ENTimeExpressionParser.js

@@ -13,10 +13,10 @@ var FIRST_REG_PATTERN  = new RegExp("(^|\\s|T)" +
     "(?:" + 
         "(?:\\.|\\:|\\：)(\\d{1,2})" + 
         "(?:" + 
-            "(?:\\:|\\：)(\\d{2})" + 
+            "(?:\\:|\\：)(\\d{2})(?:\\.(\\d{1,6}))?" + 
         ")?" + 
     ")?" + 
-    "(?:\\s*(A\\.M\\.|P\\.M\\.|AM?|PM?))?" + 
+    "(?:\\s*(A\\.M\\.|P\\.M\\.|AM?|PM?|O\\W*CLOCK))?" + 
     "(?=\\W|$)", 'i');
 
 
@@ -26,16 +26,17 @@ var SECOND_REG_PATTERN = new RegExp("^\\s*" +
     "(?:" + 
         "(?:\\.|\\:|\\：)(\\d{1,2})" + 
         "(?:" + 
-            "(?:\\.|\\:|\\：)(\\d{1,2})" + 
+            "(?:\\.|\\:|\\：)(\\d{1,2})(?:\\.(\\d{1,6}))?" + 
         ")?" + 
     ")?" + 
-    "(?:\\s*(A\\.M\\.|P\\.M\\.|AM?|PM?))?" + 
+    "(?:\\s*(A\\.M\\.|P\\.M\\.|AM?|PM?|O\\W*CLOCK))?" + 
     "(?=\\W|$)", 'i');
 
 var HOUR_GROUP    = 2;
 var MINUTE_GROUP  = 3;
 var SECOND_GROUP  = 4;
-var AM_PM_HOUR_GROUP = 5;
+var MILLI_SECOND_GROUP  = 5;
+var AM_PM_HOUR_GROUP = 6;
 
 
 exports.Parser = function ENTimeExpressionParser(){
@@ -45,7 +46,7 @@ exports.Parser = function ENTimeExpressionParser(){
     
     this.extract = function(text, ref, match, opt){ 
         
-        // This pattern can be overlaped Ex. [12] AM, 1[2] AM
+        // This pattern can be overlapped Ex. [12] AM, 1[2] AM
         if (match.index > 0 && text[match.index-1].match(/\w/)) return null;
         var refMoment = moment(ref);
         var result = new ParsedResult();
@@ -62,6 +63,14 @@ exports.Parser = function ENTimeExpressionParser(){
         var minute = 0;
         var meridiem = -1;
 
+        // ----- Millisecond
+        if(match[MILLI_SECOND_GROUP] != null){ 
+            var millisecond = parseInt(match[MILLI_SECOND_GROUP].substring(0, 3));
+            if(millisecond >= 1000) return null;
+            
+            result.start.assign('millisecond', millisecond);
+        }
+
         // ----- Second
         if(match[SECOND_GROUP] != null){ 
             var second = parseInt(match[SECOND_GROUP]);
@@ -127,16 +136,12 @@ exports.Parser = function ENTimeExpressionParser(){
                 result.start.imply('meridiem', 1);
             }
         }
-        
+
         // ==============================================================
         //                  Extracting the 'to' chunk
         // ==============================================================
         match = SECOND_REG_PATTERN.exec(text.substring(result.index + result.text.length));
         if (!match) {
-            // Not accept number only result
-            if (result.text.match(/^\d+$/)) { 
-                return null;
-            }
             return result;
         }
 
@@ -155,6 +160,14 @@ exports.Parser = function ENTimeExpressionParser(){
         var minute = 0;
         var meridiem = -1;
 
+        // ----- Millisecond
+        if(match[MILLI_SECOND_GROUP] != null){ 
+            var millisecond = parseInt(match[MILLI_SECOND_GROUP].substring(0, 3));
+            if(millisecond >= 1000) return null;
+            
+            result.end.assign('millisecond', millisecond);
+        }
+        
         // ----- Second
         if(match[SECOND_GROUP] != null){ 
             var second = parseInt(match[SECOND_GROUP]);