keyValueStore.get('active-version').then(activeVersion => {
// activeVersion is undefined for sw-null
// if the main version has changed, bail
if (activeVersion &&
semver.parse(activeVersion).major !== semver.parse(self.version).major) {
return;
}
console.log('activeVersion', activeVersion);
}).catch(console.log.bind(console));
module.exports.get_version = function(object, version) {
if (object.versions[version] != null) return object.versions[version]
try {
version = Semver.parse(version, true)
for (var k in object.versions) {
if (version.compare(Semver.parse(k, true)) === 0) {
return object.versions[k]
}
}
} catch (err) {
return undefined
}
}
export function diffWithUnstable(version1: string, version2: string): Release | null {
if (semver.eq(version1, version2) === false) {
const v1 = semver.parse(version1);
const v2 = semver.parse(version2);
if (v1 != null && v2 != null) {
const isPreRelease = v1.prerelease.length > 0 || v2.prerelease.length > 0;
const preMajor = v1.major === 0 || v2.major === 0;
const preMinor = preMajor && (v1.minor === 0 || v2.minor === 0);
let diff = null;
if (v1.major !== v2.major) {
diff = 'major';
} else if (v1.minor !== v2.minor) {
if (preMajor) {
// If the major version number is zero (0.x.x), treat a change
// of the minor version number as a major change.
diff = 'major';
} else {
diff = 'minor';
}
} else if (v1.patch !== v2.patch) {
if (preMinor) {
// If the major & minor version numbers are zero (0.0.x), treat a change
// of the patch version number as a major change.
diff = 'major';
} else if (preMajor) {
// If the major version number is zero (0.x.x), treat a change
// of the patch version number as a minor change.
diff = 'minor';
} else {
diff = 'patch';
}
}
if (isPreRelease) {
if (diff != null) {
diff = PRE_RELEASES[diff];
} else {
diff = 'prerelease';
}
}
return diff;
}
}
return null;
}
/**
* Gets version from a package object taking into account semver weirdness.
* @param {*} object
* @param {*} version
* @return {String} return the semantic version of a package
*/
function get_version(object, version) {
// this condition must allow cast
if (object.versions[version] != null) {
return object.versions[version];
}
try {
version = semver.parse(version, true);
for (let k in object.versions) {
if (version.compare(semver.parse(k, true)) === 0) {
return object.versions[k];
}
}
} catch (err) {
return undefined;
}
}
.filter(function(x) {
if (!semver.parse(x, true)) {
Logger.logger.warn({ ver: x }, 'ignoring bad version @{ver}');
return false;
}
return true;
})
/**
* @param {string} tag
*/
function parseTagVersion(tag) {
try {
return tag && semver.parse(tag).version;
} catch (e) {
return;
}
}
export function normalizeDistTags(pkg: Package) {
let sorted;
if (!pkg[DIST_TAGS].latest) {
// overwrite latest with highest known version based on semver sort
sorted = semverSort(Object.keys(pkg.versions));
if (sorted && sorted.length) {
pkg[DIST_TAGS].latest = sorted.pop();
}
}
for (const tag in pkg[DIST_TAGS]) {
if (_.isArray(pkg[DIST_TAGS][tag])) {
if (pkg[DIST_TAGS][tag].length) {
// sort array
// $FlowFixMe
sorted = semverSort(pkg[DIST_TAGS][tag]);
if (sorted.length) {
// use highest version based on semver sort
pkg[DIST_TAGS][tag] = sorted.pop();
}
} else {
delete pkg[DIST_TAGS][tag];
}
} else if (_.isString(pkg[DIST_TAGS][tag])) {
if (!semver.parse(pkg[DIST_TAGS][tag], true)) {
// if the version is invalid, delete the dist-tag entry
delete pkg[DIST_TAGS][tag];
}
}
}
}
module.exports.normalize_dist_tags = function (data) {
var sorted
if (!data['dist-tags'].latest) {
// overwrite latest with highest known version based on semver sort
sorted = module.exports.semver_sort(Object.keys(data.versions))
if (sorted && sorted.length) {
data['dist-tags'].latest = sorted.pop()
}
}
for (var tag in data['dist-tags']) {
if (Array.isArray(data['dist-tags'][tag])) {
if (data['dist-tags'][tag].length) {
// sort array
sorted = module.exports.semver_sort(data['dist-tags'][tag])
if (sorted.length) {
// use highest version based on semver sort
data['dist-tags'][tag] = sorted.pop()
}
} else {
delete data['dist-tags'][tag]
}
} else if (typeof data['dist-tags'][tag] === 'string') {
if (!Semver.parse(data['dist-tags'][tag], true)) {
// if the version is invalid, delete the dist-tag entry
delete data['dist-tags'][tag]
}
}
}
}
grunt.registerTask("build-installer-linux", "Build linux installer", function () {
var template = grunt.file.read("installer/linux/debian/control"),
templateData = {},
content;
// populate debian control template fields
templateData.version = grunt.file.readJSON(grunt.config("config-json")).version;
templateData.size = 0;
templateData.arch = (common.arch() === 64) ? "amd64" : "i386";
// uncompressed file size
grunt.file.recurse("installer/linux/debian/package-root/opt", function (abspath) {
templateData.size += fs.statSync(abspath).size;
});
templateData.size = Math.round(templateData.size / 1000);
// write file
content = grunt.template.process(template, { data: templateData });
grunt.file.write("installer/linux/debian/package-root/DEBIAN/control", content);
var done = this.async(),
version = semver.parse(grunt.config("pkg").version),
release = version.major + "." + version.minor;
spawn(["bash build_installer.sh"], { cwd: resolve("installer/linux"), env: getBracketsEnv() }).then(function () {
return common.rename("installer/linux/brackets.deb", "installer/linux/Brackets Release " + release + " " + common.arch() + "-bit.deb");
}).then(function () {
done();
}, function (err) {
grunt.log.error(err);
done(false);
});
});
function getTargetVersion () {
// 'python' should be set by now
process.env.PYTHON = python
if (gyp.opts.target) {
// if --target was given, then ensure that version is installed
versionStr = gyp.opts.target
gyp.verbose('compiling against --target node version', versionStr)
} else {
// if no --target was specified then use the current host node version
versionStr = process.version
gyp.verbose('no --target version specified, falling back to host node version', versionStr)
}
version = semver.parse(versionStr)
if (!version) {
return callback(new Error('Invalid version number: ' + versionStr))
}
gyp.opts.ensure = true
gyp.commands.install([ versionStr ], function (err, _version) {
if (err) return callback(err)
version = _version
gyp.verbose('setting target version to:', version)
createBuildDir()
})
}
function isVersionMatch(packageVersion, requestVersion, requestTag) {
const { major, minor } = semver.parse(packageVersion);
const minVersion = semver.minVersion(requestVersion);
return major === minVersion.major &&
minor === minVersion.minor &&
isTagMatch(packageVersion, requestTag);
}
/**
* Flatten arrays of tags.
* @param {*} data
*/
function normalize_dist_tags(data) {
let sorted;
if (!data['dist-tags'].latest) {
// overwrite latest with highest known version based on semver sort
sorted = semverSort(Object.keys(data.versions));
if (sorted && sorted.length) {
data['dist-tags'].latest = sorted.pop();
}
}
for (let tag in data['dist-tags']) {
if (_.isArray(data['dist-tags'][tag])) {
if (data['dist-tags'][tag].length) {
// sort array
sorted = semverSort(data['dist-tags'][tag]);
if (sorted.length) {
// use highest version based on semver sort
data['dist-tags'][tag] = sorted.pop();
}
} else {
delete data['dist-tags'][tag];
}
} else if (_.isString(data['dist-tags'][tag] )) {
if (!semver.parse(data['dist-tags'][tag], true)) {
// if the version is invalid, delete the dist-tag entry
delete data['dist-tags'][tag];
}
}
}
}
exports.prerelease = function prerelease(version) {
var parsed = semver.parse(version);
return parsed
&& parsed.prerelease
&& parsed.prerelease.length;
};
export default (version) => {
let isPrerelease = semver.parse(version).prerelease.length > 0;
let result = Promise.resolve();
let output = isPrerelease ? alphaChangelog : changelog;
let additionalArgs = '';
let removedAlphaChangelog = false;
if (!isPrerelease) {
result = fsp.exists(alphaChangelog)
.then(exists => {
if (!exists) {
return null;
}
removedAlphaChangelog = true;
return exec(`rimraf ${alphaChangelog}`);
});
additionalArgs = ' --exclude-pre-releases';
}
return result
.then(() => exec(`changelog --title v${version} --out ${output}${additionalArgs}`))
.then(() => safeExec(`git add ${changelog}`))
.then(() => {
if (removedAlphaChangelog || isPrerelease) {
return safeExec(`git add -A ${alphaChangelog}`);
}
})
.then(() => console.log('Generated Changelog'.cyan));
};
function remove (gyp, argv, callback) {
var devDir = gyp.devDir
log.verbose('remove', 'using node-gyp dir:', devDir)
// get the user-specified version to remove
var version = argv[0] || gyp.opts.target
log.verbose('remove', 'removing target version:', version)
if (!version) {
return callback(new Error('You must specify a version number to remove. Ex: "' + process.version + '"'))
}
var versionSemver = semver.parse(version)
if (versionSemver) {
// flatten the version Array into a String
version = versionSemver.version
}
var versionPath = path.resolve(gyp.devDir, version)
log.verbose('remove', 'removing development files for version:', version)
// first check if its even installed
fs.stat(versionPath, function (err) {
if (err) {
if (err.code == 'ENOENT') {
callback(null, 'version was already uninstalled: ' + version)
} else {
callback(err)
}
return
}
// Go ahead and delete the dir
rm(versionPath, callback)
})
}
module.exports = function (version, type) {
if (['major', 'minor', 'patch'].indexOf(type) === -1) {
throw new TypeError('Invalid version type');
}
version = semver.parse(version, {loose: true});
if (!version) {
throw new Error('Version ' + version + ' is not valid semver');
}
version.build = '';
version.prerelease = '';
if (type === 'minor') {
version.patch = 0;
}
if (type === 'major') {
version.patch = 0;
version.minor = 0;
}
return version.format();
};
it("pulp docs --with-tests", run(function*(sh, pulp, assert) {
const pursVer = yield getPursVersion(sh, assert);
if (semver.gte(pursVer, semver.parse('0.13.0'))) {
yield pulp("init");
yield pulp("docs --with-tests");
assert.file("generated-docs/html/Test.Main.html");
}
}));
const getPursVersion = co.wrap(function*(sh, assert) {
const [out] = yield sh("purs --version");
const pursVer = semver.parse(out.split(/\s/)[0]);
if (pursVer == null) {
assert.fail("Unable to parse output of purs --version");
}
return pursVer;
});
export function tagVersion(data: Package, version: string, tag: StringValue): boolean {
if (tag && data[DIST_TAGS][tag] !== version && semver.parse(version, true)) {
// valid version - store
data[DIST_TAGS][tag] = version;
return true;
}
return false;
}
return lines.map((line) => {
let parsed = line.match(TAG_REGEX);
if (parsed) {
let [match, version, target] = parsed;
if (semver.parse(version)) {
return { version, target };
}
}
});
.map(tag => {
return {
tag,
semver: semver.parse(tag),
toString() {
return tag;
}
};
})
versions.forEach(function (version) {
var v = semver.parse(version);
if (!version_to_choose) {
version_to_choose = version;
} else {
var parsed = semver.parse(version_to_choose);
if (parsed.major == v.major) {
// error
conflict = true;
} else if (parsed.minor == v.minor) {
// warn
self.emit("warn", util("multi minor version %s@%s <-> %s@%s", name, version, name, version_to_choose_raw));
if (parsed.minor < v.minor) {
version_to_choose = version;
}
}
}
});
export function getVersion(pkg: Package, version: any) {
// this condition must allow cast
if (_.isNil(pkg.versions[version]) === false) {
return pkg.versions[version];
}
try {
version = semver.parse(version, true);
for (const versionItem in pkg.versions) {
// $FlowFixMe
if (version.compare(semver.parse(versionItem, true)) === 0) {
return pkg.versions[versionItem];
}
}
} catch (err) {
return undefined;
}
}
// Captures all the logic required to determine download URLs, local directory and
// file names. Inputs come from command-line switches (--target, --dist-url).
function processRelease (argv, gyp/*, defaultVersion, defaultRelease*/) {
// nw-gyp: `defaultVersion` and `defaultRelease` are meaningless for NW.js
var version = (semver.valid(argv[0]) && argv[0]) || gyp.opts.target
, versionSemver = semver.parse(version)
, overrideDistUrl = gyp.opts['dist-url'] || gyp.opts.disturl
, distBaseUrl
, baseUrl
, libUrl32
, libUrl64
, nodeLibUrl32
, nodeLibUrl32
, tarballUrl
, canGetHeaders
if (!versionSemver) {
// not a valid semver string, nothing we can do
return { version: version }
}
// flatten version into String
version = versionSemver.version
// nw-gyp: `overrideDistUrl` should be redirected to NW.js by default
if (!overrideDistUrl) {
overrideDistUrl = 'http://node-webkit.s3.amazonaws.com';
}
distBaseUrl = overrideDistUrl.replace(/\/+$/, '')
distBaseUrl += '/v' + version + '/'
baseUrl = distBaseUrl
nodeLibUrl32 = resolveLibUrl('node', baseUrl, 'ia32', versionSemver.major)
nodeLibUrl64 = resolveLibUrl('node', baseUrl, 'x64', versionSemver.major)
libUrl32 = resolveLibUrl('nw', baseUrl, 'ia32', versionSemver.major)
libUrl64 = resolveLibUrl('nw', baseUrl, 'x64', versionSemver.major)
tarballUrl = url.resolve(baseUrl, 'nw-headers-v' + version + '.tar.gz')
return {
version: version,
semver: versionSemver,
name: 'nw',
baseUrl: baseUrl,
tarballUrl: tarballUrl,
shasumsUrl: url.resolve(baseUrl, 'SHASUMS256.txt'),
versionDir: version,
libUrl32: libUrl32,
libUrl64: libUrl64,
nodeLibUrl32: nodeLibUrl32,
nodeLibUrl64: nodeLibUrl64,
libPath32: normalizePath(path.relative(url.parse(baseUrl).path, url.parse(libUrl32).path)),
libPath64: normalizePath(path.relative(url.parse(baseUrl).path, url.parse(libUrl64).path)),
nodeLibPath32: normalizePath(path.relative(url.parse(baseUrl).path, url.parse(nodeLibUrl32).path)),
nodeLibPath64: normalizePath(path.relative(url.parse(baseUrl).path, url.parse(nodeLibUrl64).path))
}
}
exports.stableVersionsPackageValidator = function(pkg, name, cb) {
var rootRange, rootRangeParsed, notStrictRanges;
if ( (rootRange = pkg.ranges._root) ) {
// if root range is present and it is strict
if ( semver.parse(rootRange) ) {
return cb(null);
}
rootRangeParsed = semver.validRange(rootRange);
}
notStrictRanges = _.chain(pkg.ranges)
.omit('_root')
.map(function(range, parent) {
if ( semver.parse(range) ) {
return null;
}
return {
parsed: semver.validRange(range),
parent: parent,
range: range
}
})
.filter()
.value();
if (!_.isEmpty(notStrictRanges)) {
cb(
'Unstable version for the package "' + name + '@' + pkg.current_version + '":\n' +
notStrictRanges
.map(function(def) {
return 'subpackage "' + def.parent + '" requires it as ' + def.range + (def.parsed ? (' (' + def.parsed + ')') : '');
})
.map(function(str) {
return '\t' + str;
})
.join('\n') +
'\n' +
(
rootRange
? '\troot package requires it as ' + rootRange + (rootRangeParsed ? (' (' + rootRangeParsed + ')') : '')
: '\troot package does not require it'
) +
'\n' +
'\n' +
'This subpackage should be hoisted to the root package dependencies with strict version definition.' +
'\n'
);
return;
}
cb(null);
};
function clean(version) {
var parsed = semver.parse(version);
if (!parsed) {
return null;
}
// Keep builds!
return parsed.version + (parsed.build.length ? '+' + parsed.build.join('.') : '');
}
/**
* @param {string} packageVersion
* @param {string} sha
* @param {string=} channel
*/
function buildVersion(packageVersion, sha, channel) {
let base = semver.parse(packageVersion);
let major = base.major;
let minor = base.minor;
let patch = base.patch;
let suffix = '';
suffix += toSuffix('-', base.prerelease, channel);
suffix += toSuffix('+', base.build, sha);
return `${major}.${minor}.${patch}${suffix}`;
}
check: function () {
if (!('version' in this.json.config)) {
bail('ERROR: Could not find version in ' + this.fileName);
}
this.ver = semver.parse(this.json.config.version);
if (this.ver === null) {
bail('ERROR: Incorrect version in ' + this.fileName);
}
},
function checkVersion(json, report) {
if ('version' in json) {
var v = semver.parse(json.version);
if (!v) {
report(fmt('Version "%s" is invalid', json.version));
} else if (!semver.gte(json.version, '1.0.0-0')) {
// the only versions below 1.0.0 allowed are pre-releases of 1.0.0
report(fmt('Version "%s" is lower than 1.0.0', json.version));
}
}
}
.map(function(range, parent) {
if ( semver.parse(range) ) {
return null;
}
return {
parsed: semver.validRange(range),
parent: parent,
range: range
}
})