improve dateTime2ms edge cases and standardize BADNUM and FP_SAFE constants

Author: alexcjohnson

src/lib/constants.js

@@ -0,0 +1,27 @@
+/**
+* Copyright 2012-2016, Plotly, Inc.
+* All rights reserved.
+*
+* This source code is licensed under the MIT license found in the
+* LICENSE file in the root directory of this source tree.
+*/
+
+'use strict';
+
+
+module.exports = {
+    /**
+     * Standardize all missing data in calcdata to use undefined
+     * never null or NaN.
+     * That way we can use !==undefined, or !== BADNUM,
+     * to test for real data
+     */
+    BADNUM: undefined,
+
+    /*
+     * Limit certain operations to well below floating point max value
+     * to avoid glitches: Make sure that even when you multiply it by the
+     * number of pixels on a giant screen it still works
+     */
+    FP_SAFE: Number.MAX_VALUE / 10000
+};

src/lib/dates.js

@@ -11,26 +11,32 @@
 
 var d3 = require('d3');
 var isNumeric = require('fast-isnumeric');
-
+var BADNUM = require('./constants').BADNUM;
 
 /**
  * dateTime2ms - turn a date object or string s of the form
  * YYYY-mm-dd HH:MM:SS.sss into milliseconds (relative to 1970-01-01,
  * per javascript standard)
  * may truncate after any full field, and sss can be any length
  * even >3 digits, though javascript dates truncate to milliseconds
- * returns false if it doesn't find a date
+ * returns BADNUM if it doesn't find a date
+ *
+ * Expanded to support negative years to -9999 but you must always
+ * give 4 digits, except for 2-digit positive years which we assume are
+ * near the present time.
+ * Note that we follow ISO 8601:2004: there *is* a year 0, which
+ * is 1BC/BCE, and -1===2BC etc.
  *
  * 2-digit to 4-digit year conversion, where to cut off?
  * from http://support.microsoft.com/kb/244664:
  *   1930-2029 (the most retro of all...)
  * but in my mac chrome from eg. d=new Date(Date.parse('8/19/50')):
  *   1950-2049
  * by Java, from http://stackoverflow.com/questions/2024273/:
- *   now-80 - now+20
+ *   now-80 - now+19
  * or FileMaker Pro, from
  *      http://www.filemaker.com/12help/html/add_view_data.4.21.html:
- *   now-70 - now+30
+ *   now-70 - now+29
  * but python strptime etc, via
  *      http://docs.python.org/py3k/library/time.html:
  *   1969-2068 (super forward-looking, but static, not sliding!)
@@ -39,8 +45,8 @@ var isNumeric = require('fast-isnumeric');
  * they can learn the hard way not to use 2-digit years, as no choice we
  * make now will cover all possibilities. mostly this will all be taken
  * care of in initial parsing, should only be an issue for hand-entered data
- * currently (2012) this range is:
- *   1942-2041
+ * currently (2016) this range is:
+ *   1946-2045
  */
 
 exports.dateTime2ms = function(s) {
@@ -49,63 +55,96 @@ exports.dateTime2ms = function(s) {
         if(s.getTime) return +s;
     }
     catch(e) {
-        return false;
+        return BADNUM;
     }
 
     var y, m, d, h;
     // split date and time parts
     var datetime = String(s).split(' ');
-    if(datetime.length > 2) return false;
+    if(datetime.length > 2) return BADNUM;
 
     var p = datetime[0].split('-'); // date part
-    if(p.length > 3 || (p.length !== 3 && datetime[1])) return false;
+
+    var CE = true; // common era, ie positive year
+    if(p[0] === '') {
+        // first part is blank: year starts with a minus sign
+        CE = false;
+        p.splice(0, 1);
+    }
+
+    if(p.length > 3 || (p.length !== 3 && datetime[1])) return BADNUM;
 
     // year
     if(p[0].length === 4) y = Number(p[0]);
     else if(p[0].length === 2) {
+        if(!CE) return BADNUM;
         var yNow = new Date().getFullYear();
         y = ((Number(p[0]) - yNow + 70) % 100 + 200) % 100 + yNow - 70;
     }
-    else return false;
-    if(!isNumeric(y)) return false;
-    if(p.length === 1) return new Date(y, 0, 1).getTime(); // year only
-
-    // month
-    m = Number(p[1]) - 1; // new Date() uses zero-based months
-    if(p[1].length > 2 || !(m >= 0 && m <= 11)) return false;
-    if(p.length === 2) return new Date(y, m, 1).getTime(); // year-month
-
-    // day
-    d = Number(p[2]);
-    if(p[2].length > 2 || !(d >= 1 && d <= 31)) return false;
-
-    // now save the date part
-    d = new Date(y, m, d).getTime();
-    if(!datetime[1]) return d; // year-month-day
-    p = datetime[1].split(':');
-    if(p.length > 3) return false;
-
-    // hour
-    h = Number(p[0]);
-    if(p[0].length > 2 || !(h >= 0 && h <= 23)) return false;
-    d += 3600000 * h;
-    if(p.length === 1) return d;
-
-    // minute
-    m = Number(p[1]);
-    if(p[1].length > 2 || !(m >= 0 && m <= 59)) return false;
-    d += 60000 * m;
-    if(p.length === 2) return d;
-
-    // second
-    s = Number(p[2]);
-    if(!(s >= 0 && s < 60)) return false;
-    return d + s * 1000;
+    else return BADNUM;
+    if(!isNumeric(y)) return BADNUM;
+
+    // javascript takes new Date(0..99,m,d) to mean 1900-1999, so
+    // to support years 0-99 we need to use setFullYear explicitly
+    var baseDate = new Date(0, 0, 1);
+    baseDate.setFullYear(CE ? y : -y);
+    if(p.length > 1) {
+
+        // month
+        m = Number(p[1]) - 1; // new Date() uses zero-based months
+        if(p[1].length > 2 || !(m >= 0 && m <= 11)) return BADNUM;
+        baseDate.setMonth(m);
+
+        if(p.length > 2) {
+
+            // day
+            d = Number(p[2]);
+            if(p[2].length > 2 || !(d >= 1 && d <= 31)) return BADNUM;
+            baseDate.setDate(d);
+
+            // does that date exist in this month?
+            if(baseDate.getDate() !== d) return BADNUM;
+
+            if(datetime[1]) {
+
+                p = datetime[1].split(':');
+                if(p.length > 3) return BADNUM;
+
+                // hour
+                h = Number(p[0]);
+                if(p[0].length > 2 || !(h >= 0 && h <= 23)) return BADNUM;
+                baseDate.setHours(h);
+
+                // does that hour exist in this day? (Daylight time!)
+                // (TODO: remove this check when we move to UTC)
+                if(baseDate.getHours() !== h) return BADNUM;
+
+                if(p.length > 1) {
+                    d = baseDate.getTime();
+
+                    // minute
+                    m = Number(p[1]);
+                    if(p[1].length > 2 || !(m >= 0 && m <= 59)) return BADNUM;
+                    d += 60000 * m;
+                    if(p.length === 2) return d;
+
+                    // second (and milliseconds)
+                    s = Number(p[2]);
+                    if(!(s >= 0 && s < 60)) return BADNUM;
+                    return d + s * 1000;
+                }
+            }
+        }
+    }
+    return baseDate.getTime();
 };
 
+exports.MIN_MS = exports.dateTime2ms('-9999');
+exports.MAX_MS = exports.dateTime2ms('9999');
+
 // is string s a date? (see above)
 exports.isDateTime = function(s) {
-    return (exports.dateTime2ms(s) !== false);
+    return (exports.dateTime2ms(s) !== BADNUM);
 };
 
 // pad a number with zeroes, to given # of digits before the decimal point
@@ -123,6 +162,8 @@ function lpad(val, digits) {
 exports.ms2DateTime = function(ms, r) {
     if(!r) r = 0;
 
+    if(ms < exports.MIN_MS || ms > exports.MAX_MS) return BADNUM;
+
     var d = new Date(ms),
         s = d3.time.format('%Y-%m-%d')(d);
 

src/lib/index.js

@@ -36,6 +36,8 @@ lib.dateTime2ms = datesModule.dateTime2ms;
 lib.isDateTime = datesModule.isDateTime;
 lib.ms2DateTime = datesModule.ms2DateTime;
 lib.parseDate = datesModule.parseDate;
+lib.MIN_MS = datesModule.MIN_MS;
+lib.MAX_MS = datesModule.MAX_MS;
 
 var searchModule = require('./search');
 lib.findBin = searchModule.findBin;
@@ -75,6 +77,10 @@ lib.error = loggersModule.error;
 
 lib.notifier = require('./notifier');
 
+var constantsModule = require('./constants');
+lib.BADNUM = constantsModule.BADNUM,
+lib.FP_SAFE = constantsModule.FP_SAFE;
+
 /**
  * swap x and y of the same attribute in container cont
  * specify attr with a ? in place of x/y

src/plots/cartesian/axes.js

@@ -19,6 +19,8 @@ var Titles = require('../../components/titles');
 var Color = require('../../components/color');
 var Drawing = require('../../components/drawing');
 
+var FP_SAFE = Lib.FP_SAFE;
+
 
 var axes = module.exports = {};
 
@@ -304,7 +306,6 @@ axes.saveRangeInitial = function(gd, overwrite) {
 //          (unless one end is overridden by tozero)
 //      tozero: (boolean) make sure to include zero if axis is linear,
 //          and make it a tight bound if possible
-var FP_SAFE = Number.MAX_VALUE / 2;
 axes.expand = function(ax, data, options) {
     if(!(ax.autorange || ax._needsExpand) || !data) return;
     if(!ax._min) ax._min = [];

src/plots/cartesian/constants.js

@@ -21,14 +21,6 @@ module.exports = {
         y: /^yaxis([2-9]|[1-9][0-9]+)?$/
     },
 
-    /**
-     * standardize all missing data in calcdata to use undefined
-     * never null or NaN.
-     * that way we can use !==undefined, or !== BADNUM,
-     * to test for real data
-     */
-    BADNUM: undefined,
-
     // axis match regular expression
     xAxisMatch: /^xaxis[0-9]*$/,
     yAxisMatch: /^yaxis[0-9]*$/,

src/plots/cartesian/set_convert.js

@@ -13,6 +13,8 @@ var d3 = require('d3');
 var isNumeric = require('fast-isnumeric');
 
 var Lib = require('../../lib');
+var FP_SAFE = Lib.FP_SAFE;
+var BADNUM = Lib.BADNUM;
 
 var constants = require('./constants');
 var cleanDatum = require('./clean_datum');
@@ -128,7 +130,7 @@ module.exports = function setConvert(ax) {
     };
 
     ax.l2p = function(v) {
-        if(!isNumeric(v)) return constants.BADNUM;
+        if(!isNumeric(v)) return BADNUM;
 
         // include 2 fractional digits on pixel, for PDF zooming etc
         return d3.round(ax._b + ax._m * v, 2);
@@ -197,7 +199,7 @@ module.exports = function setConvert(ax) {
             }
 
             var c = ax._categories.indexOf(v);
-            return c === -1 ? constants.BADNUM : c;
+            return c === -1 ? BADNUM : c;
         };
 
         ax.d2l = ax.d2c;