postgres-interval 2.1.0 → 3.0.0

package/index.js

@@ -7,10 +7,6 @@ function PostgresInterval (raw) {
     return new PostgresInterval(raw)
   }
 
-  for (const key in positions) {
-    this[key] = 0
-  }
-
   Object.assign(this, parse(raw))
 }
 const properties = ['seconds', 'minutes', 'hours', 'days', 'months', 'years']
@@ -88,55 +84,73 @@ function toISOString ({ short = false }) {
 }
 
 const NUMBER = '([+-]?\\d+)'
-const YEAR = NUMBER + '\\s+years?'
-const MONTH = NUMBER + '\\s+mons?'
-const DAY = NUMBER + '\\s+days?'
-const TIME = '([+-])?([\\d]*):(\\d\\d):(\\d\\d)\\.?(\\d{1,6})?'
-const INTERVAL = new RegExp([YEAR, MONTH, DAY, TIME].map(function (regexString) {
-  return '(' + regexString + ')?'
+const YEAR = `${NUMBER}\\s+years?`
+const MONTH = `${NUMBER}\\s+mons?`
+const DAY = `${NUMBER}\\s+days?`
+// NOTE: PostgreSQL automatically overflows seconds into minutes and minutes
+// into hours, so we can rely on minutes and seconds always being 2 digits
+// (plus decimal for seconds). The overflow stops at hours - hours do not
+// overflow into days, so could be arbitrarily long.
+const TIME = '([+-])?(\\d+):(\\d\\d):(\\d\\d(?:\\.\\d{1,6})?)'
+const INTERVAL = new RegExp(
+  '^\\s*' +
+    // All parts of an interval are optional
+    [YEAR, MONTH, DAY, TIME].map((str) => '(?:' + str + ')?').join('\\s*') +
+    '\\s*$'
+)
+
+// All intervals will have exactly these properties:
+const ZERO_INTERVAL = Object.freeze({
+  years: 0,
+  months: 0,
+  days: 0,
+  hours: 0,
+  minutes: 0,
+  seconds: 0,
+  milliseconds: 0.0
 })
-  .join('\\s*'))
-
-// Positions of values in regex match
-const positions = {
-  years: 2,
-  months: 4,
-  days: 6,
-  hours: 9,
-  minutes: 10,
-  seconds: 11,
-  milliseconds: 12
-}
-// We can use negative time
-const negatives = ['hours', 'minutes', 'seconds', 'milliseconds']
-
-function parseMilliseconds (fraction) {
-  // add omitted zeroes
-  const microseconds = fraction + '000000'.slice(fraction.length)
-  return parseInt(microseconds, 10) / 1000
-}
 
 function parse (interval) {
-  if (!interval) return {}
-  const matches = INTERVAL.exec(interval)
-  const isNegative = matches[8] === '-'
-  return Object.keys(positions)
-    .reduce(function (parsed, property) {
-      const position = positions[property]
-      let value = matches[position]
-      // no empty string
-      if (!value) return parsed
-      // milliseconds are actually microseconds (up to 6 digits)
-      // with omitted trailing zeroes.
-      value = property === 'milliseconds'
-        ? parseMilliseconds(value)
-        : parseInt(value, 10)
-      // no zeros
-      if (!value) return parsed
-      if (isNegative && ~negatives.indexOf(property)) {
-        value *= -1
-      }
-      parsed[property] = value
-      return parsed
-    }, {})
+  if (!interval) {
+    return ZERO_INTERVAL
+  }
+
+  const matches = INTERVAL.exec(interval) || []
+
+  const [
+    ,
+    yearsString,
+    monthsString,
+    daysString,
+    plusMinusTime,
+    hoursString,
+    minutesString,
+    secondsString
+  ] = matches
+
+  const timeMultiplier = plusMinusTime === '-' ? -1 : 1
+
+  const years = yearsString ? parseInt(yearsString, 10) : 0
+  const months = monthsString ? parseInt(monthsString, 10) : 0
+  const days = daysString ? parseInt(daysString, 10) : 0
+  const hours = hoursString ? timeMultiplier * parseInt(hoursString, 10) : 0
+  const minutes = minutesString
+    ? timeMultiplier * parseInt(minutesString, 10)
+    : 0
+  const secondsFloat = parseFloat(secondsString) || 0
+  // secondsFloat is guaranteed to be >= 0, so floor is safe
+  const absSeconds = Math.floor(secondsFloat)
+  const seconds = timeMultiplier * absSeconds
+  // Without the rounding, we end up with decimals like 455.99999999999994 instead of 456
+  const milliseconds = Math.round(timeMultiplier * (secondsFloat - absSeconds) * 1000000) / 1000
+  return {
+    years,
+    months,
+    days,
+    hours,
+    minutes,
+    seconds,
+    milliseconds
+  }
 }
+PostgresInterval.parse = parse

package/package.json

@@ -1,17 +1,17 @@
 {
   "name": "postgres-interval",
   "main": "index.js",
-  "version": "2.1.0",
+  "version": "3.0.0",
   "description": "Parse Postgres interval columns",
   "license": "MIT",
   "repository": "bendrucker/postgres-interval",
   "author": {
     "name": "Ben Drucker",
     "email": "bvdrucker@gmail.com",
-    "url": "bendrucker.me"
+    "url": "https://www.bendrucker.me"
   },
   "engines": {
-    "node": ">=8"
+    "node": ">=12"
   },
   "scripts": {
     "test": "standard && tape test.js"
@@ -23,7 +23,7 @@
   ],
   "dependencies": {},
   "devDependencies": {
-    "standard": "^14.0.0",
+    "standard": "^16.0.0",
     "tape": "^5.0.0"
   },
   "files": [

package/readme.md

@@ -1,4 +1,4 @@
-# postgres-interval [![Build Status](https://travis-ci.org/bendrucker/postgres-interval.svg?branch=master)](https://travis-ci.org/bendrucker/postgres-interval)
+# postgres-interval [![tests](https://github.com/bendrucker/postgres-interval/workflows/tests/badge.svg)](https://github.com/bendrucker/postgres-interval/actions?query=workflow%3Atests)
 
 > Parse Postgres interval columns