Merge 6ca0949 into 07244f9

bin/semver.js

@@ -3,39 +3,37 @@
 // Exits successfully and prints matching version(s) if
 // any supplied version is valid and passes all tests.
 
-var argv = process.argv.slice(2)
+const argv = process.argv.slice(2)
 
-var versions = []
+let versions = []
 
-var range = []
+const range = []
 
-var inc = null
+let inc = null
 
-var version = require('../package.json').version
+const version = require('../package.json').version
 
-var loose = false
+let loose = false
 
-var includePrerelease = false
+let includePrerelease = false
 
-var coerce = false
+let coerce = false
 
-var rtl = false
+let rtl = false
 
-var identifier
+let identifier
 
-var semver = require('../semver')
+const semver = require('../')
 
-var reverse = false
+let reverse = false
 
-var options = {}
+const options = {}
 
-main()
-
-function main () {
+const main = () => {
   if (!argv.length) return help()
   while (argv.length) {
-    var a = argv.shift()
-    var indexOfEqualSign = a.indexOf('=')
+    let a = argv.shift()
+    const indexOfEqualSign = a.indexOf('=')
     if (indexOfEqualSign !== -1) {
       a = a.slice(0, indexOfEqualSign)
       argv.unshift(a.slice(indexOfEqualSign + 1))
@@ -87,88 +85,89 @@ function main () {
     }
   }
 
-  var options = { loose: loose, includePrerelease: includePrerelease, rtl: rtl }
+  const options = { loose: loose, includePrerelease: includePrerelease, rtl: rtl }
 
-  versions = versions.map(function (v) {
+  versions = versions.map((v) => {
     return coerce ? (semver.coerce(v, options) || { version: v }).version : v
-  }).filter(function (v) {
+  }).filter((v) => {
     return semver.valid(v)
   })
   if (!versions.length) return fail()
   if (inc && (versions.length !== 1 || range.length)) { return failInc() }
 
-  for (var i = 0, l = range.length; i < l; i++) {
-    versions = versions.filter(function (v) {
+  for (let i = 0, l = range.length; i < l; i++) {
+    versions = versions.filter((v) => {
       return semver.satisfies(v, range[i], options)
     })
     if (!versions.length) return fail()
   }
   return success(versions)
 }
 
-function failInc () {
+
+const failInc = () => {
   console.error('--inc can only be used on a single version with no range')
   fail()
 }
 
-function fail () { process.exit(1) }
+const fail = () => process.exit(1)
 
-function success () {
-  var compare = reverse ? 'rcompare' : 'compare'
-  versions.sort(function (a, b) {
+const success = () => {
+  const compare = reverse ? 'rcompare' : 'compare'
+  versions.sort((a, b) => {
     return semver[compare](a, b, options)
-  }).map(function (v) {
+  }).map((v) => {
     return semver.clean(v, options)
-  }).map(function (v) {
+  }).map((v) => {
     return inc ? semver.inc(v, inc, options, identifier) : v
-  }).forEach(function (v, i, _) { console.log(v) })
+  }).forEach((v, i, _) => { console.log(v) })
 }
 
-function help () {
-  console.log(['SemVer ' + version,
-    '',
-    'A JavaScript implementation of the https://semver.org/ specification',
-    'Copyright Isaac Z. Schlueter',
-    '',
-    'Usage: semver [options] <version> [<version> [...]]',
-    'Prints valid versions sorted by SemVer precedence',
-    '',
-    'Options:',
-    '-r --range <range>',
-    '        Print versions that match the specified range.',
-    '',
-    '-i --increment [<level>]',
-    '        Increment a version by the specified level.  Level can',
-    '        be one of: major, minor, patch, premajor, preminor,',
-    "        prepatch, or prerelease.  Default level is 'patch'.",
-    '        Only one version may be specified.',
-    '',
-    '--preid <identifier>',
-    '        Identifier to be used to prefix premajor, preminor,',
-    '        prepatch or prerelease version increments.',
-    '',
-    '-l --loose',
-    '        Interpret versions and ranges loosely',
-    '',
-    '-p --include-prerelease',
-    '        Always include prerelease versions in range matching',
-    '',
-    '-c --coerce',
-    '        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.',
-    '',
-    'If no satisfying versions are found, then exits failure.',
-    '',
-    'Versions are printed in ascending order, so supplying',
-    'multiple versions to the utility will just sort them.'
-  ].join('\n'))
-}
+const help = () => console.log(
+`SemVer ${version}
+
+A JavaScript implementation of the https://semver.org/ specification
+Copyright Isaac Z. Schlueter
+
+Usage: semver [options] <version> [<version> [...]]
+Prints valid versions sorted by SemVer precedence
+
+Options:
+-r --range <range>
+        Print versions that match the specified range.
+
+-i --increment [<level>]
+        Increment a version by the specified level.  Level can
+        be one of: major, minor, patch, premajor, preminor,
+        prepatch, or prerelease.  Default level is 'patch'.
+        Only one version may be specified.
+
+--preid <identifier>
+        Identifier to be used to prefix premajor, preminor,
+        prepatch or prerelease version increments.
+
+-l --loose
+        Interpret versions and ranges loosely
+
+-p --include-prerelease
+        Always include prerelease versions in range matching
+
+-c --coerce
+        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.
+
+If no satisfying versions are found, then exits failure.
+
+Versions are printed in ascending order, so supplying
+multiple versions to the utility will just sort them.`)
+
+main()

classes/comparator.js

@@ -0,0 +1,139 @@
+const ANY = Symbol('SemVer ANY')
+// hoisted class for cyclic dependency
+class Comparator {
+  static get ANY () {
+    return ANY
+  }
+  constructor (comp, options) {
+    if (!options || typeof options !== 'object') {
+      options = {
+        loose: !!options,
+        includePrerelease: false
+      }
+    }
+
+    if (comp instanceof Comparator) {
+      if (comp.loose === !!options.loose) {
+        return comp
+      } else {
+        comp = comp.value
+      }
+    }
+
+    debug('comparator', comp, options)
+    this.options = options
+    this.loose = !!options.loose
+    this.parse(comp)
+
+    if (this.semver === ANY) {
+      this.value = ''
+    } else {
+      this.value = this.operator + this.semver.version
+    }
+
+    debug('comp', this)
+  }
+
+  parse (comp) {
+    const r = this.options.loose ? re[t.COMPARATORLOOSE] : re[t.COMPARATOR]
+    const m = comp.match(r)
+
+    if (!m) {
+      throw new TypeError(`Invalid comparator: ${comp}`)
+    }
+
+    this.operator = m[1] !== undefined ? m[1] : ''
+    if (this.operator === '=') {
+      this.operator = ''
+    }
+
+    // if it literally is just '>' or '' then allow anything.
+    if (!m[2]) {
+      this.semver = ANY
+    } else {
+      this.semver = new SemVer(m[2], this.options.loose)
+    }
+  }
+
+  toString () {
+    return this.value
+  }
+
+  test (version) {
+    debug('Comparator.test', version, this.options.loose)
+
+    if (this.semver === ANY || version === ANY) {
+      return true
+    }
+
+    if (typeof version === 'string') {
+      try {
+        version = new SemVer(version, this.options)
+      } catch (er) {
+        return false
+      }
+    }
+
+    return cmp(version, this.operator, this.semver, this.options)
+  }
+
+  intersects (comp, options) {
+    if (!(comp instanceof Comparator)) {
+      throw new TypeError('a Comparator is required')
+    }
+
+    if (!options || typeof options !== 'object') {
+      options = {
+        loose: !!options,
+        includePrerelease: false
+      }
+    }
+
+    if (this.operator === '') {
+      if (this.value === '') {
+        return true
+      }
+      return new Range(comp.value, options).test(this.value)
+    } else if (comp.operator === '') {
+      if (comp.value === '') {
+        return true
+      }
+      return new Range(this.value, options).test(comp.semver)
+    }
+
+    const sameDirectionIncreasing =
+      (this.operator === '>=' || this.operator === '>') &&
+      (comp.operator === '>=' || comp.operator === '>')
+    const sameDirectionDecreasing =
+      (this.operator === '<=' || this.operator === '<') &&
+      (comp.operator === '<=' || comp.operator === '<')
+    const sameSemVer = this.semver.version === comp.semver.version
+    const differentDirectionsInclusive =
+      (this.operator === '>=' || this.operator === '<=') &&
+      (comp.operator === '>=' || comp.operator === '<=')
+    const oppositeDirectionsLessThan =
+      cmp(this.semver, '<', comp.semver, options) &&
+      (this.operator === '>=' || this.operator === '>') &&
+        (comp.operator === '<=' || comp.operator === '<')
+    const oppositeDirectionsGreaterThan =
+      cmp(this.semver, '>', comp.semver, options) &&
+      (this.operator === '<=' || this.operator === '<') &&
+        (comp.operator === '>=' || comp.operator === '>')
+
+    return (
+      sameDirectionIncreasing ||
+      sameDirectionDecreasing ||
+      (sameSemVer && differentDirectionsInclusive) ||
+      oppositeDirectionsLessThan ||
+      oppositeDirectionsGreaterThan
+    )
+  }
+}
+
+module.exports = Comparator
+
+const {re, t} = require('../internal/re')
+const cmp = require('../functions/cmp')
+const debug = require('../internal/debug')
+const SemVer = require('./semver')
+const Range = require('./range')

classes/index.js

@@ -0,0 +1,5 @@
+module.exports = {
+  SemVer: require('./semver.js'),
+  Range: require('./range.js'),
+  Comparator: require('./comparator.js')
+}