package/package.json000644 000765 000024 0000001224 13145656145013026 0ustar00000000 000000 { "name": "sver-compat", "version": "1.5.0", "description": "Simple Semver and SemverRange classes", "main": "sver.js", "scripts": { "test": "mocha -u tdd -R dot" }, "repository": { "type": "git", "url": "git+ssh://git@github.com/phated/sver-compat.git" }, "keywords": [ "semver" ], "author": "Guy Bedford", "license": "MIT", "bugs": { "url": "https://github.com/phated/sver-compat/issues" }, "homepage": "https://github.com/phated/sver-compat#readme", "devDependencies": { "mocha": "^3.4.2", "semver": "^5.3.0" }, "dependencies": { "es6-iterator": "^2.0.1", "es6-symbol": "^3.1.1" } } package/.npmignore000644 000765 000024 0000000027 13145127227012531 0ustar00000000 000000 package-lock.json test package/README.md000644 000765 000024 0000013757 13145650564012034 0ustar00000000 000000 # sver-compat [![Build Status](https://travis-ci.org/phated/sver-compat.svg?branch=master)](https://travis-ci.org/phated/sver-compat) Fork of @guybedford's [Sver](https://github.com/guybedford/sver) library. Adds compatibility for node <6. ``` npm install sver-compat ``` ```js var Semver = require('sver-compat').Semver; var SemverRange = require('sver-compat').SemverRange; // Static usage: SemverRange.match('^1.2.3', '1.2.4'); // true // Class usage: var range = new SemverRange('^1.2.3'); var version = new Semver('1.2.4'); version.matches(range); // true range.has(version); // true ``` ### Range support Restricts version ranges to the simplified cases: * `*`: Wildcard range * `MAJOR`: Match exact major * `MAJOR.MINOR` Match exact major and minor * `MAJOR.MINOR.PATCH[-PRE]` Match exact semver * `~MAJOR.MINOR.PATCH[-PRE]`: Match patch bumps * `^MAJOR.MINOR.PATCH[-PRE]`: Match minor and patch bumps Invalid ranges will fallback to being detected as exact string matches. ### Prerelease Matching By default, as per convention, ranges like `^1.2.3-alpha` only match prerelease ranges on the same patch (`1.2.3-alpha.4`), but not prerelease ranges from further patches (`1.3.4-alpha`). To alter this matching, a third boolean argument can be provided to the match function to support these unstable matches: ```js SemverRange.match('^1.2.3', '1.5.6-beta'); // false SemverRange.match('^1.2.3', '1.5.6-beta', true); // true ``` ### Best Version Match ```js var versions = ['1.2.3', '1.3.4-alpha', '1.3.4-alpha.1', '1.3.4-beta']; var range = new SemverRange('*'); var bestStableMatch = range.bestMatch(versions); bestStableMatch.toString(); // 1.2.3 var bestUnstableMatch = range.bestMatch(versions, true); bestUnstableMatch.toString(); // 1.3.4-beta ``` ### Version and Range Sorting ```js var versions = ['2.4.5', '2.3.4-alpha', '1.2.3', '2.3.4-alpha.2']; var ranges = ['^1.2.3', '1.2', '2.3.4']; versions.sort(Semver.compare); // [1.2.3, 2.3.4-alpha, 2.3.4-alpha.2, 2.4.5] ranges.sort(SemverRange.compare) // [1.2, ^1.2.3, 2.3.4] ``` ### Conversion from Node Semver Ranges A utility function is included to convert Node Semver ranges into Semver ranges. This requires `semver` to be installed in the application running this process. _Note this conversion is lossy by definition._ ```js var convertRange = require('sver-compat/convert-range'); convertRange('>=2.3.4 <3.0.0').toString(); // ^2.3.4 convertRange('1 || 2 || 3').toString(); // ^3.0.0 ``` ### Semver and Semver Range Validation When a version string fails semver validation it falls back to being treated as a tag, still as a `Semver` instance. For example: ```js var version = new Semver('x.y.z'); version.tag === 'x.y.z'; // true version = new Semver('^1.2.3'); version.major === undefined; // true version.tag === '^1.2.3'; // true ``` For validation, rather use `Semver.isValid` and `SemverRange.isValid`: ```js Semver.isValid('x.y.z'); // false Semver.isValid('^1.2.3'); // false SemverRange.isValid('^1.2.3'); // true ``` ## API ### Semver Static methods: * `Semver.isValid(version: string): boolean`: Whether the given string is a valid semver. * `Semver.compare(v1: Semver|string, v2: Semver|string): number`: 1 if v1 > v2, -1 if v1 < v2, 0 if equal. For a given Semver instance `version = new Semver('X.Y.Z')`, * `version.major`: The major version number. * `version.minor`: The minor version number. * `version.patch`: The patch version number. * `version.pre`: The prerelease identifer, as an array of strings (`.`-separated). * `version.build`: The build identifier, as a string. * `version.tag`: If not a valid semver, the full tag string. * `version.gt(otherVersion: Semver|string): bool`: Whether this version is greater than the other version. * `version.lt(otherVersion: Semver|string): bool`: Whether this version is less than the other version. * `version.eq(otherVerion: Semver|string): bool`: Whether this version equals the other version. * `version.matches(range: SemverRange|string, unstable?: bool): bool`: Whether this version matches the given version range. * `version.toString(): string`: Convert the version back to a string. ### SemverRange Static methods: * `SemverRange.match(range: SemverRange|string, version: Semver|string, unstable = false): bool`: Whether the version matches the range. * `SemverRange.isValid(range: string): bool`: Whether the given range string is a valid semver range (in this simplified grammar). * `SemverRange.compare(r1: SemverRange|string, r2: SemverRange|string): number`: 1 if r1 > r2, -1 if r1 < r2, 0 if equal. For a given SemverRange instance `range = new SemverRange('^X.Y.Z')`, * `range.type: string`: Returns `'wildcard'`, `'major'`, `'stable'` or `'exact'`. * `range.version: Smever`: Returns the `Semver` instance corresponding to the range. * `range.isExact: string`: Returns true if the range is an exact version only. * `range.isStable: string`: Returns true if the range is a stable version range. * `range.isMajor: string`: Returns true if the range is a major version range. * `range.isWildcard: string`: Returns true if the range is the wildcard version range. * `range.gt(otherRange: SemverRange|string): bool`: Whether the range is greater than the other range. * `range.lt(otherRange: SemverRange|string): bool`: Whether the range is less than the other range. * `range.eq(otherRange: SemverRange|string): bool`: Whether the range is exactly the same as the other range. * `range.has(version: Semver|string, unstable = false): bool`: Whether the range includes the given version. * `range.contains(otherRange: SemverRange|string): bool`: Whether the range fully contains the other range. * `range.intersect(otherRange: SemverRange|string): SemverRange|undefined`: The intersection range, if any. * `range.bestMatch(versions: (Semver|string)[], unstable = false): Semver|undefined`: The intersection range, if any. * `range.toString()`: Convert the range back to a string. ## License MIT package/LICENSE000644 000765 000024 0000002070 13145127227011537 0ustar00000000 000000 MIT License ----------- Copyright (C) 2017 Guy Bedford Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. package/convert-range.js000644 000765 000024 0000010237 13145656114013650 0ustar00000000 000000 var nodeSemver = require('semver'); var sver = require('./sver'); var Semver = sver.Semver; var SemverRange = sver.SemverRange; var forOf = require('es6-iterator/for-of'); module.exports = function nodeRangeToSemverRange (range) { var parsed = nodeSemver.validRange(range); // tag version if (!parsed) return new SemverRange(range); if (parsed === '*') return new SemverRange(parsed); try { var semverRange = new SemverRange(range); if (!semverRange.version.tag) return semverRange; } catch (e) { if (e.code !== 'ENOTSEMVER') throw e; } var outRange; forOf(parsed.split('||'), function(union) { // compute the intersection into a lowest upper bound and a highest lower bound var upperBound, lowerBound, upperEq, lowerEq; forOf(union.split(' '), function(intersection, doBreak) { var lt = intersection[0] === '<'; var gt = intersection[0] === '>'; if (!lt && !gt) { upperBound = intersection; upperEq = true; return doBreak(); } var eq = intersection[1] === '='; if (!gt) { var version = new Semver(intersection.substr(1 + eq)); if (!upperBound || upperBound.gt(version)) { upperBound = version; upperEq = eq; } } else if (!lt) { var eq = intersection[1] === '='; var version = new Semver(intersection.substr(1 + eq)); if (!lowerBound || lowerBound.lt(version)) { lowerBound = version; lowerEq = eq; } } }); // if the lower bound is greater than the upper bound then just return the lower bound exactly if (lowerBound && upperBound && lowerBound.gt(upperBound)) { var curRange = new SemverRange(lowerBound.toString()); // the largest or highest union range wins if (!outRange || !outRange.contains(curRange) && (curRange.gt(outRange) || curRange.contains(outRange))) outRange = curRange; return; } // determine the largest semver range satisfying the upper bound var upperRange; if (upperBound) { // if the upper bound has an equality then we return it directly if (upperEq) { var curRange = new SemverRange(upperBound.toString()); // the largest or highest union range wins if (!outRange || !outRange.contains(curRange) && (curRange.gt(outRange) || curRange.contains(outRange))) outRange = curRange; return; } // prerelease ignored in upper bound var major = 0, minor = 0, patch = 0, rangeType = ''; // <2.0.0 -> ^1.0.0 if (upperBound.patch === 0) { if (upperBound.minor === 0) { if (upperBound.major > 0) { major = upperBound.major - 1; rangeType = '^'; } } // <1.2.0 -> ~1.1.0 else { major = upperBound.major; minor = upperBound.minor - 1; rangeType = '~'; } } // <1.2.3 -> ~1.2.0 else { major = upperBound.major; minor = upperBound.minor; patch = 0; rangeType = '~'; } if (major === 0 && rangeType === '^') upperRange = new SemverRange('0'); else upperRange = new SemverRange(rangeType + major + '.' + minor + '.' + patch); } // determine the lower range semver range var lowerRange; if (!lowerEq) { if (lowerBound.pre) lowerRange = new SemverRange('^' + lowerBound.major + '.' + lowerBound.minor + '.' + lowerBound.patch + '-' + lowerBound.pre.join('.') + '.1'); else lowerRange = new SemverRange('^' + lowerBound.major + '.' + lowerBound.minor + '.' + (lowerBound.patch + 1)); } else { lowerRange = new SemverRange('^' + lowerBound.toString()); } // we then intersect the upper semver range with the lower semver range // if the intersection is empty, we return the upper range only var curRange = upperRange ? lowerRange.intersect(upperRange) || upperRange : lowerRange; // the largest or highest union range wins if (!outRange || !outRange.contains(curRange) && (curRange.gt(outRange) || curRange.contains(outRange))) outRange = curRange; }); return outRange; } package/sver.js000644 000765 000024 0000027215 13145656561012067 0ustar00000000 000000 'use strict'; var shortSemverRegEx = /^([~\^])?(0|[1-9]\d*)(?:\.(0|[1-9]\d*))?$/; var semverRegEx = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-([\da-z-]+(?:\.[\da-z-]+)*))?(\+[\da-z-]+)?$/i; exports.semverRegEx = semverRegEx; exports.shortSemverRegEx = shortSemverRegEx; var Symbol = require('es6-symbol'); var MAJOR = Symbol('major'); var MINOR = Symbol('minor'); var PATCH = Symbol('patch'); var PRE = Symbol('pre'); var BUILD = Symbol('build'); var TAG = Symbol('tag'); var numRegEx = /^\d+$/; function Semver(version) { var semver = version.match(semverRegEx); if (!semver) { this[TAG] = version; return; } this[MAJOR] = parseInt(semver[1], 10); this[MINOR] = parseInt(semver[2], 10); this[PATCH] = parseInt(semver[3], 10); this[PRE] = semver[4] && semver[4].split('.'); this[BUILD] = semver[5]; } Object.defineProperty(Semver.prototype, 'major', { get: function major () { return this[MAJOR]; } }); Object.defineProperty(Semver.prototype, 'minor', { get: function minor () { return this[MINOR]; } }); Object.defineProperty(Semver.prototype, 'patch', { get: function patch () { return this[PATCH]; } }); Object.defineProperty(Semver.prototype, 'pre', { get: function pre () { return this[PRE]; } }); Object.defineProperty(Semver.prototype, 'build', { get: function build () { return this[BUILD]; } }); Object.defineProperty(Semver.prototype, 'tag', { get: function tag () { return this[TAG]; } }); Semver.prototype.gt = function gt(version) { return Semver.compare(this, version) === 1; } Semver.prototype.lt = function lt (version) { return Semver.compare(this, version) === -1; } Semver.prototype.eq = function eq (version) { if (!(version instanceof Semver)) version = new Semver(version); if (this[TAG] && version[TAG]) return this[TAG] === version[TAG]; if (this[TAG] || version[TAG]) return false; if (this[MAJOR] !== version[MAJOR]) return false; if (this[MINOR] !== version[MINOR]) return false; if (this[PATCH] !== version[PATCH]) return false; if (this[PRE] === undefined && version[PRE] === undefined) return true; if (this[PRE] === undefined || version[PRE] === undefined) return false; if (this[PRE].length !== version[PRE].length) return false; for (var i = 0; i < this[PRE].length; i++) { if (this[PRE][i] !== version[PRE][i]) return false; } return this[BUILD] === version[BUILD]; } Semver.prototype.matches = function matches (range, unstable) { unstable = unstable || false; if (!(range instanceof SemverRange)) range = new SemverRange(range); return range.has(this, unstable); } Semver.prototype.toString = function toString () { if (this[TAG]) return this[TAG]; return this[MAJOR] + '.' + this[MINOR] + '.' + this[PATCH] + (this[PRE] ? '-' + this[PRE].join('.') : '') + (this[BUILD] ? this[BUILD] : ''); } Semver.isValid = function isValid (version) { var semver = version.match(semverRegEx); return semver && semver[2] !== undefined && semver[3] !== undefined; } Semver.compare = function compare (v1, v2) { if (!(v1 instanceof Semver)) v1 = new Semver(v1); if (!(v2 instanceof Semver)) v2 = new Semver(v2); // not semvers - tags have equal precedence if (v1[TAG] && v2[TAG]) return 0; // semver beats tag version if (v1[TAG]) return -1; if (v2[TAG]) return 1; // compare version numbers if (v1[MAJOR] !== v2[MAJOR]) return v1[MAJOR] > v2[MAJOR] ? 1 : -1; if (v1[MINOR] !== v2[MINOR]) return v1[MINOR] > v2[MINOR] ? 1 : -1; if (v1[PATCH] !== v2[PATCH]) return v1[PATCH] > v2[PATCH] ? 1 : -1; if (!v1[PRE] && !v2[PRE]) return 0; if (!v1[PRE]) return 1; if (!v2[PRE]) return -1; // prerelease comparison for (var i = 0, l = Math.min(v1[PRE].length, v2[PRE].length); i < l; i++) { if (v1[PRE][i] !== v2[PRE][i]) { var isNum1 = v1[PRE][i].match(numRegEx); var isNum2 = v2[PRE][i].match(numRegEx); // numeric has lower precedence if (isNum1 && !isNum2) return -1; if (isNum2 && !isNum1) return 1; // compare parts if (isNum1 && isNum2) return parseInt(v1[PRE][i], 10) > parseInt(v2[PRE][i], 10) ? 1 : -1; else return v1[PRE][i] > v2[PRE][i] ? 1 : -1; } } if (v1[PRE].length === v2[PRE].length) return 0; // more pre-release fields win if equal return v1[PRE].length > v2[PRE].length ? 1 : -1; } exports.Semver = Semver; var WILDCARD_RANGE = 0; var MAJOR_RANGE = 1; var STABLE_RANGE = 2; var EXACT_RANGE = 3; var TYPE = Symbol('type'); var VERSION = Symbol('version'); function SemverRange(versionRange) { if (versionRange === '*' || versionRange === '') { this[TYPE] = WILDCARD_RANGE; return; } var shortSemver = versionRange.match(shortSemverRegEx); if (shortSemver) { if (shortSemver[1]) versionRange = versionRange.substr(1); if (shortSemver[3] === undefined) { // ^, ~ mean the same thing for a single major this[VERSION] = new Semver(versionRange + '.0.0'); this[TYPE] = MAJOR_RANGE; } else { this[VERSION] = new Semver(versionRange + '.0'); // ^ only becomes major range for major > 0 if (shortSemver[1] === '^' && shortSemver[2] !== '0') this[TYPE] = MAJOR_RANGE; else this[TYPE] = STABLE_RANGE; } // empty pre array === support prerelease ranges this[VERSION][PRE] = this[VERSION][PRE] || []; } else if (versionRange[0] === '^') { this[VERSION] = new Semver(versionRange.substr(1)); if (this[VERSION][MAJOR] === 0) { if (this[VERSION][MINOR] === 0) this[TYPE] = EXACT_RANGE; else this[TYPE] = STABLE_RANGE; } else { this[TYPE] = MAJOR_RANGE; } } else if (versionRange[0] === '~') { this[VERSION] = new Semver(versionRange.substr(1)); this[TYPE] = STABLE_RANGE; } else { this[VERSION] = new Semver(versionRange); this[TYPE] = EXACT_RANGE; } if (this[VERSION][TAG] && this[TYPE] !== EXACT_RANGE) this[TYPE] = EXACT_RANGE; } Object.defineProperty(SemverRange.prototype, 'isExact', { get: function isExact () { return this[TYPE] === EXACT_RANGE; } }); Object.defineProperty(SemverRange.prototype, 'isStable', { get: function isStable () { return this[TYPE] === STABLE_RANGE; } }); Object.defineProperty(SemverRange.prototype, 'isMajor', { get: function isMajor () { return this[TYPE] === MAJOR_RANGE; } }); Object.defineProperty(SemverRange.prototype, 'isWildcard', { get: function isWildcard () { return this[TYPE] === WILDCARD_RANGE; } }); Object.defineProperty(SemverRange.prototype, 'type', { get: function type () { switch (this[TYPE]) { case WILDCARD_RANGE: return 'wildcard'; case MAJOR_RANGE: return 'major'; case STABLE_RANGE: return 'stable'; case EXACT_RANGE: return 'exact'; } } }); Object.defineProperty(SemverRange.prototype, 'version', { get: function version () { return this[VERSION]; } }); SemverRange.prototype.gt = function gt (range) { return SemverRange.compare(this, range) === 1; } SemverRange.prototype.lt = function lt (range) { return SemverRange.compare(this, range) === -1; } SemverRange.prototype.eq = function eq (range) { return SemverRange.compare(this, range) === 0; } SemverRange.prototype.has = function has (version, unstable) { unstable = unstable || false; if (!(version instanceof Semver)) version = new Semver(version); if (this[TYPE] === WILDCARD_RANGE) return true; if (this[TYPE] === EXACT_RANGE) return this[VERSION].eq(version); if (version[TAG]) return false; if (version.lt(this[VERSION])) return false; if (version[PRE] && !unstable) return this[VERSION][MAJOR] === version[MAJOR] && this[VERSION][MINOR] === version[MINOR] && this[VERSION][PATCH] === version[PATCH]; if (this[TYPE] === MAJOR_RANGE) return this[VERSION][MAJOR] === version[MAJOR]; return this[VERSION][MAJOR] === version[MAJOR] && this[VERSION][MINOR] === version[MINOR]; } SemverRange.prototype.contains = function contains (range) { if (!(range instanceof SemverRange)) range = new SemverRange(range); if (this[TYPE] === WILDCARD_RANGE) return true; if (range[TYPE] === WILDCARD_RANGE) return false; return range[TYPE] >= this[TYPE] && this.has(range[VERSION], true); } SemverRange.prototype.intersect = function intersect (range) { if (!(range instanceof SemverRange)) range = new SemverRange(range); if (this[TYPE] === WILDCARD_RANGE && range[TYPE] === WILDCARD_RANGE) return this; if (this[TYPE] === WILDCARD_RANGE) return range; if (range[TYPE] === WILDCARD_RANGE) return this; if (this[TYPE] === EXACT_RANGE) return range.has(this[VERSION], true) ? this : undefined; if (range[TYPE] === EXACT_RANGE) return this.has(range[VERSION], true) ? range : undefined; var higherRange, lowerRange, polarity; if (range[VERSION].gt(this[VERSION])) { higherRange = range; lowerRange = this; polarity = true; } else { higherRange = this; lowerRange = range; polarity = false; } if (!lowerRange.has(higherRange[VERSION], true)) return; if (lowerRange[TYPE] === MAJOR_RANGE) return polarity ? range : this; var intersection = new SemverRange(higherRange[VERSION].toString()); intersection[TYPE] = STABLE_RANGE; return intersection; } SemverRange.prototype.bestMatch = function bestMatch (versions, unstable) { unstable = unstable || false; var self = this; var maxSemver; versions.forEach(function(version) { if (!(version instanceof Semver)) version = new Semver(version); if (!self.has(version, unstable)) return; if (!unstable && version[PRE]) { if (self[TYPE] === WILDCARD_RANGE || !self[VERSION][PRE] || self[VERSION][MAJOR] !== version[MAJOR] || self[VERSION][MINOR] !== version[MINOR] || self[VERSION][PATCH] !== version[PATCH]) return; } if (!maxSemver) { maxSemver = version; } else if (Semver.compare(version, maxSemver) === 1) { maxSemver = version; } }); return maxSemver; } SemverRange.prototype.toString = function toString () { var version = this[VERSION]; switch (this[TYPE]) { case WILDCARD_RANGE: return '*'; case MAJOR_RANGE: if (version[MAJOR] === 0 && version[MINOR] === 0 && version[PATCH] === 0) return '0'; if (version[PRE] && version[PRE].length === 0 && version[PATCH] === 0) return '^' + version[MAJOR] + '.' + version[MINOR]; return '^' + version.toString(); case STABLE_RANGE: if (version[PRE] && version[PRE].length === 0 && version[PATCH] === 0) return version[MAJOR] + '.' + version[MINOR]; return '~' + version.toString(); case EXACT_RANGE: return version.toString(); } } SemverRange.match = function match (range, version, unstable) { unstable = unstable || false; if (!(version instanceof Semver)) version = new Semver(version); return version.matches(range, unstable); } SemverRange.isValid = function isValid (range) { var semverRange = new SemverRange(range); return semverRange[TYPE] !== EXACT_RANGE || semverRange[VERSION][TAG] === undefined; } SemverRange.compare = function compare (r1, r2) { if (!(r1 instanceof SemverRange)) r1 = new SemverRange(r1); if (!(r2 instanceof SemverRange)) r2 = new SemverRange(r2); if (r1[TYPE] === WILDCARD_RANGE && r2[TYPE] === WILDCARD_RANGE) return 0; if (r1[TYPE] === WILDCARD_RANGE) return 1; if (r2[TYPE] === WILDCARD_RANGE) return -1; var cmp = Semver.compare(r1[VERSION], r2[VERSION]); if (cmp !== 0) { return cmp; } if (r1[TYPE] === r2[TYPE]) return 0; return r1[TYPE] > r2[TYPE] ? 1 : -1; } exports.SemverRange = SemverRange; package/.travis.yml000644 000765 000024 0000000135 13145127502012637 0ustar00000000 000000 sudo: false language: node_js node_js: - '8' - '6' - '5' - '4' - '0.12' - '0.10'