function majorStr (release) { return `v${semver.major(release.version)}.x` }
if (semver.valid(options.drush) && semver.major(options.drush) === 8) { delete options.composer['drush/drush']; options.build.unshift(utils.getDrush(options.drush, ['drush', '--version']));
/** * Check if it has been supported. * @param {SupportInfo} info The support info. * @param {Range} configured The configured version range. */ function isSupported({ backported, supported }, configured) { if ( backported && backported.length >= 2 && !backported.every((v, i) => i === 0 || lt(backported[i - 1], v)) ) { throw new Error("Invalid BackportConfiguration") } if (supported == null) { return false } if (backported == null || backported.length === 0) { return !configured.intersects(getSemverRange(`<${supported}`)) } return !configured.intersects( getSemverRange( [...backported, supported] .map((v, i) => (i === 0 ? `<${v}` : `>=${major(v)}.0.0 <${v}`)) .join(" || ") ) ) }
function compatibility (versions, range) { const baseVersion = semver.minSatisfying(versions, range) if (!baseVersion) { throw new Error('no matching version in: ' + range) } // Ignore patch because it says nothing about compatibility. const major = semver.major(baseVersion) const minor = semver.minor(baseVersion) const short = major + '.' + minor return { major, minor, short } }
// Generates the next release version given the curent version and the next level // Level can be 'major' or 'minor' function generateNextVersion(currentVersion, level) { const version = semver.inc(currentVersion, level); const minorVer = `${semver.major(version)}.${semver.minor(version)}`; const releaseBranchName = `release-v${minorVer}`; return { version, minorVer, releaseBranchName }; }
stdout .split('\n') .slice(0, -1) .map(line => ({ offender: line.substring(0, line.indexOf('(')).trim(), current: line.substring(line.indexOf('(') + 1, line.indexOf(')')), latest: line.substring(line.lastIndexOf(' ') + 1) })) .filter(({ current, latest }) => semver.valid(current) && semver.valid(latest)) .forEach(({ offender, current, latest }) => { const mitigation = `Upgrade to v${latest} (Current: v${current})` if (semver.major(current) < semver.major(latest)) { results.high({ offender, mitigation, code: 1, description: 'Module is one or more major versions out of date' }) } else if (semver.minor(current) < semver.minor(latest)) { results.medium({ offender, mitigation, code: 2, description: 'Module is one or more minor versions out of date' }) } else if (semver.patch(current) < semver.patch(latest)) { results.low({ offender, mitigation, code: 3, description: 'Module is one or more patch versions out of date' }) } })
Object.keys(pick(report, Object.keys(deps))) .map(name => ({ ...report[name], name })) .forEach(({ name: offender, latest, current }) => { // check if semver can parse the versions at all if (!semver.parse(current) || !semver.parse(latest)) return const mitigation = `Upgrade to v${latest} (Current: v${current})` if (semver.major(current) < semver.major(latest)) { results.high({ offender, mitigation, code: `${offender}-1`, description: 'Module is one or more major versions out of date' }) } else if (semver.minor(current) < semver.minor(latest)) { results.medium({ offender, mitigation, code: `${offender}-2`, description: 'Module is one or more minor versions out of date' }) } else if (semver.patch(current) < semver.patch(latest)) { results.low({ offender, mitigation, code: `${offender}-3`, description: 'Module is one or more patch versions out of date' }) } })
async checkSecurityFixes(version, releases) { const majorVersion = major(version); const minorVersion = minor(version); const family = `${majorVersion}.${minorVersion}.x`; var latestRelease = releases.filter(release => satisfies(release.version, family))[0]; if(!latestRelease) { console.log(chalk.yellow(`Unknown Electron release "${family}", please check manually for available security fixes.`)); return confidence.TENTATIVE; } const semverTarget = `>${version} <=${latestRelease.version}`; var followingReleases = releases.filter(release => satisfies(release.version, semverTarget)); var securityFixes = false; for (let release of followingReleases) { for (let regex of this.releaseNoteSecurityFixRegex) if (regex.test(release.body)) securityFixes = confidence.CERTAIN; } return securityFixes; }
stdout .trim() .split('\n') .map(l => JSON.parse(l || '{}')) .filter(l => l.type === 'table') .map(finding => finding.data.body) .reduce((flatmap, results) => flatmap.concat(results), []) .reduce((results, [offender, current, _, latest]) => { // check if semver can parse the versions at all if (!semver.parse(current) || !semver.parse(latest)) return results const mitigation = `Upgrade to v${latest} (Current: v${current})` if (semver.major(current) < semver.major(latest)) { results.high({ offender, mitigation, code: `${offender}-1`, description: 'Module is one or more major versions out of date' }) } else if (semver.minor(current) < semver.minor(latest)) { results.medium({ offender, mitigation, code: `${offender}-2`, description: 'Module is one or more minor versions out of date' }) } else if (semver.patch(current) < semver.patch(latest)) { results.low({ offender, mitigation, code: `${offender}-3`, description: 'Module is one or more patch versions out of date' }) } return results }, new ModuleResults(key))
async run(argv) { const semver = require('semver'); const {importTask, parseExport} = require('../tasks/import'); const {SystemError} = require('../errors'); const instance = this.system.getInstance(); const {version} = parseExport(argv.file); if (semver.major(version) === 0 && semver.major(instance.version) > 1) { throw new SystemError(`v0.x export files can only be imported by Ghost v1.x versions. You are running Ghost v${instance.version}.`); } const isRunning = await instance.isRunning(); if (!isRunning) { const shouldStart = await this.ui.confirm('Ghost instance is not currently running. Would you like to start it?', true); if (!shouldStart) { throw new SystemError('Ghost instance is not currently running'); } instance.checkEnvironment(); await this.ui.run(() => instance.start(), 'Starting Ghost'); } const importTasks = await importTask(this.ui, instance, argv.file); await importTasks.run(); }
function getBaseUrl(version, url) { const basePath = bases[semver.major(version)]; if (!basePath) { throw new SystemError(`Unsupported version: ${version}`); } return `${url.replace(/\/?$/, '')}${basePath}`; }
const key = `v${semver.major(v)}`;
/** * General implementation of figuring out if the Ghost blog has started successfully. * * @returns {Promise<any>} */ async ensureStarted(options) { const portPolling = require('./utils/port-polling'); const semver = require('semver'); options = Object.assign({ stopOnError: true, port: this.instance.config.get('server.port'), host: this.instance.config.get('server.host', 'localhost'), useNetServer: semver.major(this.instance.version) >= 2 }, options || {}); try { await portPolling(options); } catch (error) { if (options.stopOnError) { try { await this.stop(); } catch (e) { // ignore stop error } } throw error; } }
checkActiveVersion(activeVersion, versionToUse, latestV1, opts = {}) { const activeMajor = semver.major(activeVersion); if (opts.v1 && activeMajor > 1) { throw new CliError({ message: 'The --v1 flag was provided, but the current version of Ghost is v2 or greater', help: 'Re-run the command without the --v1 flag', log: false }); } if (semver.lte(versionToUse, activeVersion) && !opts.force) { return null; } if (activeMajor === 1 && activeVersion !== latestV1 && semver.diff(activeVersion, versionToUse) === 'major') { const majorToUse = semver.major(versionToUse); throw new CliError({ message: `You are trying to update to Ghost v${majorToUse}, but your blog is not on the latest Ghost 1.0 version`, help: 'Instead run "ghost update v1".' }); } return versionToUse; }
get shortVersion() { return `${semver.major(this.scope.version)}.${semver.minor(this.scope.version)}`; }