semver 6.1.3 → 6.2.0

package/README.md

@@ -60,6 +60,12 @@ Options:
         Coerce a string into SemVer if possible
         (does not imply --loose)
 
+--rtl
+        Coerce version strings right to left
+
+--ltr
+        Coerce version strings left to right (default)
+
 Program exits successfully if any valid version satisfies
 all supplied ranges, and prints all satisfying versions.
 
@@ -399,19 +405,26 @@ range, use the `satisfies(version, range)` function.
 
 ### Coercion
 
-* `coerce(version)`: Coerces a string to semver if possible
-
-This aims to provide a very forgiving translation of a non-semver
-string to semver. It looks for the first digit in a string, and
-consumes all remaining characters which satisfy at least a partial semver
-(e.g., `1`, `1.2`, `1.2.3`) up to the max permitted length (256 characters).
-Longer versions are simply truncated (`4.6.3.9.2-alpha2` becomes `4.6.3`).
-All surrounding text is simply ignored (`v3.4 replaces v3.3.1` becomes `3.4.0`).
-Only text which lacks digits will fail coercion (`version one` is not valid).
-The maximum  length for any semver component considered for coercion is 16 characters;
-longer components will be ignored (`10000000000000000.4.7.4` becomes `4.7.4`).
-The maximum value for any semver component is `Integer.MAX_SAFE_INTEGER || (2**53 - 1)`;
-higher value components are invalid (`9999999999999999.4.7.4` is likely invalid).
+* `coerce(version, options)`: Coerces a string to semver if possible
+
+This aims to provide a very forgiving translation of a non-semver string to
+semver. It looks for the first digit in a string, and consumes all
+remaining characters which satisfy at least a partial semver (e.g., `1`,
+`1.2`, `1.2.3`) up to the max permitted length (256 characters).  Longer
+versions are simply truncated (`4.6.3.9.2-alpha2` becomes `4.6.3`).  All
+surrounding text is simply ignored (`v3.4 replaces v3.3.1` becomes
+`3.4.0`).  Only text which lacks digits will fail coercion (`version one`
+is not valid).  The maximum  length for any semver component considered for
+coercion is 16 characters; longer components will be ignored
+(`10000000000000000.4.7.4` becomes `4.7.4`).  The maximum value for any
+semver component is `Integer.MAX_SAFE_INTEGER || (2**53 - 1)`; higher value
+components are invalid (`9999999999999999.4.7.4` is likely invalid).
+
+If the `options.rtl` flag is set, then `coerce` will return the right-most
+coercible tuple that does not share an ending index with a longer coercible
+tuple.  For example, `1.2.3.4` will return `2.3.4` in rtl mode, not
+`4.0.0`.  `1.2.3/4` will return `4.0.0`, because the `4` is not a part of
+any other overlapping SemVer tuple.
 
 ### Clean
 

package/bin/{semver → semver.js}

@@ -19,6 +19,8 @@ var includePrerelease = false
 
 var coerce = false
 
+var rtl = false
+
 var identifier
 
 var semver = require('../semver')
@@ -71,6 +73,12 @@ function main () {
       case '-c': case '--coerce':
         coerce = true
         break
+      case '--rtl':
+        rtl = true
+        break
+      case '--ltr':
+        rtl = false
+        break
       case '-h': case '--help': case '-?':
         return help()
       default:
@@ -79,10 +87,10 @@ function main () {
     }
   }
 
-  var options = { loose: loose, includePrerelease: includePrerelease }
+  var options = { loose: loose, includePrerelease: includePrerelease, rtl: rtl }
 
   versions = versions.map(function (v) {
-    return coerce ? (semver.coerce(v) || { version: v }).version : v
+    return coerce ? (semver.coerce(v, options) || { version: v }).version : v
   }).filter(function (v) {
     return semver.valid(v)
   })
@@ -149,6 +157,12 @@ function help () {
     '        Coerce a string into SemVer if possible',
     '        (does not imply --loose)',
     '',
+    '--rtl',
+    '        Coerce version strings right to left',
+    '',
+    '--ltr',
+    '        Coerce version strings left to right (default)',
+    '',
     'Program exits successfully if any valid version satisfies',
     'all supplied ranges, and prints all satisfying versions.',
     '',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "semver",
-  "version": "6.1.3",
+  "version": "6.2.0",
   "description": "The semantic version parser used by npm.",
   "main": "semver.js",
   "scripts": {
@@ -10,12 +10,12 @@
     "postpublish": "git push origin --follow-tags"
   },
   "devDependencies": {
-    "tap": "^14.1.6"
+    "tap": "^14.3.1"
   },
   "license": "ISC",
   "repository": "https://github.com/npm/node-semver",
   "bin": {
-    "semver": "./bin/semver"
+    "semver": "./bin/semver.js"
   },
   "files": [
     "bin",

package/semver.js

@@ -160,11 +160,13 @@ src[XRANGELOOSE] = '^' + src[GTLT] + '\\s*' + src[XRANGEPLAINLOOSE] + '$'
 // Coercion.
 // Extract anything that could conceivably be a part of a valid semver
 var COERCE = R++
-src[COERCE] = '(?:^|[^\\d])' +
+src[COERCE] = '(^|[^\\d])' +
               '(\\d{1,' + MAX_SAFE_COMPONENT_LENGTH + '})' +
               '(?:\\.(\\d{1,' + MAX_SAFE_COMPONENT_LENGTH + '}))?' +
               '(?:\\.(\\d{1,' + MAX_SAFE_COMPONENT_LENGTH + '}))?' +
               '(?:$|[^\\d])'
+var COERCERTL = R++
+re[COERCERTL] = new RegExp(src[COERCE], 'g')
 
 // Tilde ranges.
 // Meaning is "reasonably at or greater than"
@@ -1541,17 +1543,47 @@ function coerce (version, options) {
     return version
   }
 
+  if (typeof version === 'number') {
+    version = String(version)
+  }
+
   if (typeof version !== 'string') {
     return null
   }
 
-  var match = version.match(re[COERCE])
+  options = options || {}
+
+  var match = null
+  if (!options.rtl) {
+    match = version.match(re[COERCE])
+  } else {
+    // Find the right-most coercible string that does not share
+    // a terminus with a more left-ward coercible string.
+    // Eg, '1.2.3.4' wants to coerce '2.3.4', not '3.4' or '4'
+    //
+    // Walk through the string checking with a /g regexp
+    // Manually set the index so as to pick up overlapping matches.
+    // Stop when we get a match that ends at the string end, since no
+    // coercible string can be more right-ward without the same terminus.
+    var next
+    while ((next = re[COERCERTL].exec(version)) &&
+      (!match || match.index + match[0].length !== version.length)
+    ) {
+      if (!match ||
+          next.index + next[0].length !== match.index + match[0].length) {
+        match = next
+      }
+      re[COERCERTL].lastIndex = next.index + next[1].length + next[2].length
+    }
+    // leave it in a clean state
+    re[COERCERTL].lastIndex = -1
+  }
 
-  if (match == null) {
+  if (match === null) {
     return null
   }
 
-  return parse(match[1] +
-    '.' + (match[2] || '0') +
-    '.' + (match[3] || '0'), options)
+  return parse(match[2] +
+    '.' + (match[3] || '0') +
+    '.' + (match[4] || '0'), options)
 }