Secure your code as it's written. Use Snyk Code to scan source code in minutes - no build needed - and fix issues immediately.
function get_node_abi(runtime, versions) {
if (!runtime) {
throw new Error("get_node_abi requires valid runtime arg");
}
if (!versions) {
throw new Error("get_node_abi requires valid process.versions object");
}
var sem_ver = semver.parse(versions.node);
if (sem_ver.major === 0 && sem_ver.minor % 2) { // odd series
// https://github.com/mapbox/node-pre-gyp/issues/124
return runtime+'-v'+versions.node;
} else {
// process.versions.modules added in >= v0.10.4 and v0.11.7
// https://github.com/joyent/node/commit/ccabd4a6fa8a6eb79d29bc3bbe9fe2b6531c2d8e
return versions.modules ? runtime+'-v' + (+versions.modules) :
'v8-' + versions.v8.split('.').slice(0,2).join('.');
}
}
module.exports.get_node_abi = get_node_abi;
function get_node_abi(runtime, versions) {
if (!runtime) {
throw new Error("get_node_abi requires valid runtime arg");
}
if (!versions) {
throw new Error("get_node_abi requires valid process.versions object");
}
var sem_ver = semver.parse(versions.node);
if (sem_ver.major === 0 && sem_ver.minor % 2) { // odd series
// https://github.com/mapbox/node-pre-gyp/issues/124
return runtime+'-v'+versions.node;
} else {
// process.versions.modules added in >= v0.10.4 and v0.11.7
// https://github.com/joyent/node/commit/ccabd4a6fa8a6eb79d29bc3bbe9fe2b6531c2d8e
return versions.modules ? runtime+'-v' + (+versions.modules) :
'v8-' + versions.v8.split('.').slice(0,2).join('.');
}
}
module.exports.get_node_abi = get_node_abi;
for (const tag in pkg[DIST_TAGS]) {
if (_.isArray(pkg[DIST_TAGS][tag])) {
if (pkg[DIST_TAGS][tag].length) {
// sort array
// FIXME: this is clearly wrong, we need to research why this is like this.
// @ts-ignore
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];
}
}
}
}
var version
var versionStr
if (gyp.opts.target) {
// if --target was given, then determine a target version to compile for
versionStr = gyp.opts.target
log.verbose('get node dir', 'compiling against --target node version: %s', versionStr)
} else {
// if no --target was specified then use the current host node version
versionStr = process.version
log.verbose('get node dir', 'no --target version specified, falling back to host node version: %s', versionStr)
}
// make sure we have a valid version
try {
version = semver.parse(versionStr)
} catch (e) {
return callback(e)
}
if (!version) {
return callback(new Error('Invalid version number: ' + versionStr))
}
// ensure that the target node version's dev files are installed
gyp.opts.ensure = true
gyp.commands.install([ versionStr ], function (err, version) {
if (err) return callback(err)
log.verbose('get node dir', 'target node version installed:', version)
nodeDir = path.resolve(gyp.devDir, version)
createBuildDir()
})
}
function get_electron_abi(runtime, target_version) {
if (!runtime) {
throw new Error("get_electron_abi requires valid runtime arg");
}
if (typeof target_version === 'undefined') {
// erroneous CLI call
throw new Error("Empty target version is not supported if electron is the target.");
}
// Electron guarantees that patch version update won't break native modules.
var sem_ver = semver.parse(target_version);
return runtime + '-v' + sem_ver.major + '.' + sem_ver.minor;
}
module.exports.get_electron_abi = get_electron_abi;
grunt.registerTask("build-linux-archive", "Build portable Linux .tar.gz", function () {
var done = this.async(),
version = semver.parse(grunt.config("pkg").version),
release = version.major + "." + version.minor;
spawn(["bash build_archive.sh"], { cwd: resolve("installer/linux"), env: getBracketsEnv() }).then(function () {
return common.rename("installer/linux/brackets.tar.gz", "installer/linux/Brackets Release " + release + " " + common.arch() + "-bit.tar.gz");
}).then(function () {
done();
}, function (err) {
grunt.log.error(err);
done(false);
});
});
};
async run() {
const spec = this.args.starter;
const dest = this.args.directory;
const args = this.cmdArgv.length >= 3 ? this.cmdArgv.slice(2) : [];
const f = this.flags(NewCommand);
const adaptVerString = f.adaptVersion || this.config.version;
if (!spec) {
throw new UserError(`Missing 1 required arg:\nstarter\nSee more help with --help`);
}
if (!dest || !isString(dest)) {
throw new UserError(`Directory argument is not a string`);
}
const adaptVersion = parse(adaptVerString);
if (!adaptVersion) {
throw new UserError(`Adapt version '${adaptVerString}' must be ` +
`a valid semver string (Example: 1.0.1)`);
}
const sshHostKeyCheck = f.sshHostKeyCheck || "unset";
if (sshHostKeyCheck === "ask") this.interactive = true;
const starter = createStarter({
adaptVersion,
args,
destDir: path.resolve(dest),
spec,
});
try {
function promoteVersion(ver) {
var vers = semver.parse(ver)
;
if (Number(vers[1])) {
return '>=' + ver + ' <' + (Number(vers[1]) + 1);
}
if (Number(vers[2])) {
return '>=' + ver + ' < 0.' + (Number(vers[2]) + 1);
}
return '=0.0.' + vers[3];
}
module.exports.evaluate = function(package_json,options) {
options = options || {};
validate_config(package_json);
var v = package_json.version;
var module_version = semver.parse(v);
var runtime = options.runtime || (process.versions['node-webkit'] ? 'node-webkit' : 'node');
var opts = {
name: package_json.name,
configuration: Boolean(options.debug) ? 'Debug' : 'Release',
debug: options.debug,
module_name: package_json.binary.module_name,
version: module_version.version,
prerelease: module_version.prerelease.length ? module_version.prerelease.join('.') : '',
build: module_version.build.length ? module_version.build.join('.') : '',
major: module_version.major,
minor: module_version.minor,
patch: module_version.patch,
runtime: runtime,
node_abi: get_runtime_abi(runtime,options.target),
target: options.target || '',
platform: options.target_platform || process.platform,
(await this.getCurrentVersion(lastRelease)) ||
latestTag;
if (!rawVersion) {
this.logger.log.error('Could not calculate next version from last tag.');
return;
}
const newVersion = parse(rawVersion)
? this.prefixRelease(rawVersion)
: rawVersion;
if (
!dryRun &&
parse(newVersion) &&
parse(lastRelease) &&
eq(newVersion, lastRelease)
) {
this.logger.log.warn(
`Nothing released to Github. Version to be released is the same as the latest release on Github: ${newVersion}`
);
return;
}
let release: Response | undefined;
if (dryRun) {
this.logger.log.info(
`Would have released (unless ran with "shipit"): ${newVersion}`
);
} else {
this.logger.log.info(`Releasing ${newVersion} to GitHub.`);