diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 19882c8..be425fe 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -11,7 +11,7 @@ jobs: os: ["windows-latest", "ubuntu-latest"] name: Test the action steps: - - uses: actions/checkout@v2 + - uses: actions/checkout@v3 - name: Setup PDM uses: ./ with: diff --git a/dist/setup-pdm.js b/dist/setup-pdm.js index 7ff8811..b4c16eb 100644 --- a/dist/setup-pdm.js +++ b/dist/setup-pdm.js @@ -2286,7 +2286,7 @@ var require_exec = __commonJS((exports2) => { }); } exports2.exec = exec5; - function getExecOutput(commandLine, args, options) { + function getExecOutput2(commandLine, args, options) { var _a, _b; return __awaiter(this, void 0, void 0, function* () { let stdout = ""; @@ -2318,7 +2318,7 @@ var require_exec = __commonJS((exports2) => { }; }); } - exports2.getExecOutput = getExecOutput; + exports2.getExecOutput = getExecOutput2; }); // node_modules/setup-python/node_modules/semver/internal/constants.js @@ -4497,7 +4497,7 @@ var require_semver2 = __commonJS((exports2, module2) => { }; }); -// node_modules/semver/semver.js +// node_modules/@actions/tool-cache/node_modules/semver/semver.js var require_semver3 = __commonJS((exports2, module2) => { exports2 = module2.exports = SemVer; var debug2; @@ -6478,6 +6478,932 @@ var require_tool_cache = __commonJS((exports2) => { } }); +// node_modules/semver/internal/constants.js +var require_constants2 = __commonJS((exports2, module2) => { + var SEMVER_SPEC_VERSION = "2.0.0"; + var MAX_LENGTH = 256; + var MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER || 9007199254740991; + var MAX_SAFE_COMPONENT_LENGTH = 16; + module2.exports = { + SEMVER_SPEC_VERSION, + MAX_LENGTH, + MAX_SAFE_INTEGER, + MAX_SAFE_COMPONENT_LENGTH + }; +}); + +// node_modules/semver/internal/debug.js +var require_debug2 = __commonJS((exports2, module2) => { + var debug2 = typeof process === "object" && process.env && process.env.NODE_DEBUG && /\bsemver\b/i.test(process.env.NODE_DEBUG) ? (...args) => console.error("SEMVER", ...args) : () => { + }; + module2.exports = debug2; +}); + +// node_modules/semver/internal/re.js +var require_re2 = __commonJS((exports2, module2) => { + var {MAX_SAFE_COMPONENT_LENGTH} = require_constants2(); + var debug2 = require_debug2(); + exports2 = module2.exports = {}; + var re = exports2.re = []; + var src = exports2.src = []; + var t = exports2.t = {}; + var R = 0; + var createToken = (name, value, isGlobal) => { + const index = R++; + debug2(name, index, value); + t[name] = index; + src[index] = value; + re[index] = new RegExp(value, isGlobal ? "g" : void 0); + }; + createToken("NUMERICIDENTIFIER", "0|[1-9]\\d*"); + createToken("NUMERICIDENTIFIERLOOSE", "[0-9]+"); + createToken("NONNUMERICIDENTIFIER", "\\d*[a-zA-Z-][a-zA-Z0-9-]*"); + createToken("MAINVERSION", `(${src[t.NUMERICIDENTIFIER]})\\.(${src[t.NUMERICIDENTIFIER]})\\.(${src[t.NUMERICIDENTIFIER]})`); + createToken("MAINVERSIONLOOSE", `(${src[t.NUMERICIDENTIFIERLOOSE]})\\.(${src[t.NUMERICIDENTIFIERLOOSE]})\\.(${src[t.NUMERICIDENTIFIERLOOSE]})`); + createToken("PRERELEASEIDENTIFIER", `(?:${src[t.NUMERICIDENTIFIER]}|${src[t.NONNUMERICIDENTIFIER]})`); + createToken("PRERELEASEIDENTIFIERLOOSE", `(?:${src[t.NUMERICIDENTIFIERLOOSE]}|${src[t.NONNUMERICIDENTIFIER]})`); + createToken("PRERELEASE", `(?:-(${src[t.PRERELEASEIDENTIFIER]}(?:\\.${src[t.PRERELEASEIDENTIFIER]})*))`); + createToken("PRERELEASELOOSE", `(?:-?(${src[t.PRERELEASEIDENTIFIERLOOSE]}(?:\\.${src[t.PRERELEASEIDENTIFIERLOOSE]})*))`); + createToken("BUILDIDENTIFIER", "[0-9A-Za-z-]+"); + createToken("BUILD", `(?:\\+(${src[t.BUILDIDENTIFIER]}(?:\\.${src[t.BUILDIDENTIFIER]})*))`); + createToken("FULLPLAIN", `v?${src[t.MAINVERSION]}${src[t.PRERELEASE]}?${src[t.BUILD]}?`); + createToken("FULL", `^${src[t.FULLPLAIN]}$`); + createToken("LOOSEPLAIN", `[v=\\s]*${src[t.MAINVERSIONLOOSE]}${src[t.PRERELEASELOOSE]}?${src[t.BUILD]}?`); + createToken("LOOSE", `^${src[t.LOOSEPLAIN]}$`); + createToken("GTLT", "((?:<|>)?=?)"); + createToken("XRANGEIDENTIFIERLOOSE", `${src[t.NUMERICIDENTIFIERLOOSE]}|x|X|\\*`); + createToken("XRANGEIDENTIFIER", `${src[t.NUMERICIDENTIFIER]}|x|X|\\*`); + createToken("XRANGEPLAIN", `[v=\\s]*(${src[t.XRANGEIDENTIFIER]})(?:\\.(${src[t.XRANGEIDENTIFIER]})(?:\\.(${src[t.XRANGEIDENTIFIER]})(?:${src[t.PRERELEASE]})?${src[t.BUILD]}?)?)?`); + createToken("XRANGEPLAINLOOSE", `[v=\\s]*(${src[t.XRANGEIDENTIFIERLOOSE]})(?:\\.(${src[t.XRANGEIDENTIFIERLOOSE]})(?:\\.(${src[t.XRANGEIDENTIFIERLOOSE]})(?:${src[t.PRERELEASELOOSE]})?${src[t.BUILD]}?)?)?`); + createToken("XRANGE", `^${src[t.GTLT]}\\s*${src[t.XRANGEPLAIN]}$`); + createToken("XRANGELOOSE", `^${src[t.GTLT]}\\s*${src[t.XRANGEPLAINLOOSE]}$`); + createToken("COERCE", `${"(^|[^\\d])(\\d{1,"}${MAX_SAFE_COMPONENT_LENGTH}})(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?(?:$|[^\\d])`); + createToken("COERCERTL", src[t.COERCE], true); + createToken("LONETILDE", "(?:~>?)"); + createToken("TILDETRIM", `(\\s*)${src[t.LONETILDE]}\\s+`, true); + exports2.tildeTrimReplace = "$1~"; + createToken("TILDE", `^${src[t.LONETILDE]}${src[t.XRANGEPLAIN]}$`); + createToken("TILDELOOSE", `^${src[t.LONETILDE]}${src[t.XRANGEPLAINLOOSE]}$`); + createToken("LONECARET", "(?:\\^)"); + createToken("CARETTRIM", `(\\s*)${src[t.LONECARET]}\\s+`, true); + exports2.caretTrimReplace = "$1^"; + createToken("CARET", `^${src[t.LONECARET]}${src[t.XRANGEPLAIN]}$`); + createToken("CARETLOOSE", `^${src[t.LONECARET]}${src[t.XRANGEPLAINLOOSE]}$`); + createToken("COMPARATORLOOSE", `^${src[t.GTLT]}\\s*(${src[t.LOOSEPLAIN]})$|^$`); + createToken("COMPARATOR", `^${src[t.GTLT]}\\s*(${src[t.FULLPLAIN]})$|^$`); + createToken("COMPARATORTRIM", `(\\s*)${src[t.GTLT]}\\s*(${src[t.LOOSEPLAIN]}|${src[t.XRANGEPLAIN]})`, true); + exports2.comparatorTrimReplace = "$1$2$3"; + createToken("HYPHENRANGE", `^\\s*(${src[t.XRANGEPLAIN]})\\s+-\\s+(${src[t.XRANGEPLAIN]})\\s*$`); + createToken("HYPHENRANGELOOSE", `^\\s*(${src[t.XRANGEPLAINLOOSE]})\\s+-\\s+(${src[t.XRANGEPLAINLOOSE]})\\s*$`); + createToken("STAR", "(<|>)?=?\\s*\\*"); + createToken("GTE0", "^\\s*>=\\s*0\\.0\\.0\\s*$"); + createToken("GTE0PRE", "^\\s*>=\\s*0\\.0\\.0-0\\s*$"); +}); + +// node_modules/semver/internal/parse-options.js +var require_parse_options2 = __commonJS((exports2, module2) => { + var opts = ["includePrerelease", "loose", "rtl"]; + var parseOptions = (options) => !options ? {} : typeof options !== "object" ? {loose: true} : opts.filter((k) => options[k]).reduce((o, k) => { + o[k] = true; + return o; + }, {}); + module2.exports = parseOptions; +}); + +// node_modules/semver/internal/identifiers.js +var require_identifiers2 = __commonJS((exports2, module2) => { + var numeric = /^[0-9]+$/; + var compareIdentifiers = (a, b) => { + const anum = numeric.test(a); + const bnum = numeric.test(b); + if (anum && bnum) { + a = +a; + b = +b; + } + return a === b ? 0 : anum && !bnum ? -1 : bnum && !anum ? 1 : a < b ? -1 : 1; + }; + var rcompareIdentifiers = (a, b) => compareIdentifiers(b, a); + module2.exports = { + compareIdentifiers, + rcompareIdentifiers + }; +}); + +// node_modules/semver/classes/semver.js +var require_semver4 = __commonJS((exports2, module2) => { + var debug2 = require_debug2(); + var {MAX_LENGTH, MAX_SAFE_INTEGER} = require_constants2(); + var {re, t} = require_re2(); + var parseOptions = require_parse_options2(); + var {compareIdentifiers} = require_identifiers2(); + var SemVer = class { + constructor(version, options) { + options = parseOptions(options); + if (version instanceof SemVer) { + if (version.loose === !!options.loose && version.includePrerelease === !!options.includePrerelease) { + return version; + } else { + version = version.version; + } + } else if (typeof version !== "string") { + throw new TypeError(`Invalid Version: ${version}`); + } + if (version.length > MAX_LENGTH) { + throw new TypeError(`version is longer than ${MAX_LENGTH} characters`); + } + debug2("SemVer", version, options); + this.options = options; + this.loose = !!options.loose; + this.includePrerelease = !!options.includePrerelease; + const m = version.trim().match(options.loose ? re[t.LOOSE] : re[t.FULL]); + if (!m) { + throw new TypeError(`Invalid Version: ${version}`); + } + this.raw = version; + this.major = +m[1]; + this.minor = +m[2]; + this.patch = +m[3]; + if (this.major > MAX_SAFE_INTEGER || this.major < 0) { + throw new TypeError("Invalid major version"); + } + if (this.minor > MAX_SAFE_INTEGER || this.minor < 0) { + throw new TypeError("Invalid minor version"); + } + if (this.patch > MAX_SAFE_INTEGER || this.patch < 0) { + throw new TypeError("Invalid patch version"); + } + if (!m[4]) { + this.prerelease = []; + } else { + this.prerelease = m[4].split(".").map((id) => { + if (/^[0-9]+$/.test(id)) { + const num = +id; + if (num >= 0 && num < MAX_SAFE_INTEGER) { + return num; + } + } + return id; + }); + } + this.build = m[5] ? m[5].split(".") : []; + this.format(); + } + format() { + this.version = `${this.major}.${this.minor}.${this.patch}`; + if (this.prerelease.length) { + this.version += `-${this.prerelease.join(".")}`; + } + return this.version; + } + toString() { + return this.version; + } + compare(other) { + debug2("SemVer.compare", this.version, this.options, other); + if (!(other instanceof SemVer)) { + if (typeof other === "string" && other === this.version) { + return 0; + } + other = new SemVer(other, this.options); + } + if (other.version === this.version) { + return 0; + } + return this.compareMain(other) || this.comparePre(other); + } + compareMain(other) { + if (!(other instanceof SemVer)) { + other = new SemVer(other, this.options); + } + return compareIdentifiers(this.major, other.major) || compareIdentifiers(this.minor, other.minor) || compareIdentifiers(this.patch, other.patch); + } + comparePre(other) { + if (!(other instanceof SemVer)) { + other = new SemVer(other, this.options); + } + if (this.prerelease.length && !other.prerelease.length) { + return -1; + } else if (!this.prerelease.length && other.prerelease.length) { + return 1; + } else if (!this.prerelease.length && !other.prerelease.length) { + return 0; + } + let i = 0; + do { + const a = this.prerelease[i]; + const b = other.prerelease[i]; + debug2("prerelease compare", i, a, b); + if (a === void 0 && b === void 0) { + return 0; + } else if (b === void 0) { + return 1; + } else if (a === void 0) { + return -1; + } else if (a === b) { + continue; + } else { + return compareIdentifiers(a, b); + } + } while (++i); + } + compareBuild(other) { + if (!(other instanceof SemVer)) { + other = new SemVer(other, this.options); + } + let i = 0; + do { + const a = this.build[i]; + const b = other.build[i]; + debug2("prerelease compare", i, a, b); + if (a === void 0 && b === void 0) { + return 0; + } else if (b === void 0) { + return 1; + } else if (a === void 0) { + return -1; + } else if (a === b) { + continue; + } else { + return compareIdentifiers(a, b); + } + } while (++i); + } + inc(release, identifier) { + switch (release) { + case "premajor": + this.prerelease.length = 0; + this.patch = 0; + this.minor = 0; + this.major++; + this.inc("pre", identifier); + break; + case "preminor": + this.prerelease.length = 0; + this.patch = 0; + this.minor++; + this.inc("pre", identifier); + break; + case "prepatch": + this.prerelease.length = 0; + this.inc("patch", identifier); + this.inc("pre", identifier); + break; + case "prerelease": + if (this.prerelease.length === 0) { + this.inc("patch", identifier); + } + this.inc("pre", identifier); + break; + case "major": + if (this.minor !== 0 || this.patch !== 0 || this.prerelease.length === 0) { + this.major++; + } + this.minor = 0; + this.patch = 0; + this.prerelease = []; + break; + case "minor": + if (this.patch !== 0 || this.prerelease.length === 0) { + this.minor++; + } + this.patch = 0; + this.prerelease = []; + break; + case "patch": + if (this.prerelease.length === 0) { + this.patch++; + } + this.prerelease = []; + break; + case "pre": + if (this.prerelease.length === 0) { + this.prerelease = [0]; + } else { + let i = this.prerelease.length; + while (--i >= 0) { + if (typeof this.prerelease[i] === "number") { + this.prerelease[i]++; + i = -2; + } + } + if (i === -1) { + this.prerelease.push(0); + } + } + if (identifier) { + if (compareIdentifiers(this.prerelease[0], identifier) === 0) { + if (isNaN(this.prerelease[1])) { + this.prerelease = [identifier, 0]; + } + } else { + this.prerelease = [identifier, 0]; + } + } + break; + default: + throw new Error(`invalid increment argument: ${release}`); + } + this.format(); + this.raw = this.version; + return this; + } + }; + module2.exports = SemVer; +}); + +// node_modules/semver/functions/parse.js +var require_parse2 = __commonJS((exports2, module2) => { + var {MAX_LENGTH} = require_constants2(); + var {re, t} = require_re2(); + var SemVer = require_semver4(); + var parseOptions = require_parse_options2(); + var parse = (version, options) => { + options = parseOptions(options); + if (version instanceof SemVer) { + return version; + } + if (typeof version !== "string") { + return null; + } + if (version.length > MAX_LENGTH) { + return null; + } + const r = options.loose ? re[t.LOOSE] : re[t.FULL]; + if (!r.test(version)) { + return null; + } + try { + return new SemVer(version, options); + } catch (er) { + return null; + } + }; + module2.exports = parse; +}); + +// node_modules/semver/functions/compare.js +var require_compare2 = __commonJS((exports2, module2) => { + var SemVer = require_semver4(); + var compare = (a, b, loose) => new SemVer(a, loose).compare(new SemVer(b, loose)); + module2.exports = compare; +}); + +// node_modules/semver/functions/eq.js +var require_eq2 = __commonJS((exports2, module2) => { + var compare = require_compare2(); + var eq = (a, b, loose) => compare(a, b, loose) === 0; + module2.exports = eq; +}); + +// node_modules/semver/functions/neq.js +var require_neq2 = __commonJS((exports2, module2) => { + var compare = require_compare2(); + var neq = (a, b, loose) => compare(a, b, loose) !== 0; + module2.exports = neq; +}); + +// node_modules/semver/functions/gt.js +var require_gt2 = __commonJS((exports2, module2) => { + var compare = require_compare2(); + var gt = (a, b, loose) => compare(a, b, loose) > 0; + module2.exports = gt; +}); + +// node_modules/semver/functions/gte.js +var require_gte2 = __commonJS((exports2, module2) => { + var compare = require_compare2(); + var gte = (a, b, loose) => compare(a, b, loose) >= 0; + module2.exports = gte; +}); + +// node_modules/semver/functions/lt.js +var require_lt2 = __commonJS((exports2, module2) => { + var compare = require_compare2(); + var lt = (a, b, loose) => compare(a, b, loose) < 0; + module2.exports = lt; +}); + +// node_modules/semver/functions/lte.js +var require_lte2 = __commonJS((exports2, module2) => { + var compare = require_compare2(); + var lte = (a, b, loose) => compare(a, b, loose) <= 0; + module2.exports = lte; +}); + +// node_modules/semver/functions/cmp.js +var require_cmp2 = __commonJS((exports2, module2) => { + var eq = require_eq2(); + var neq = require_neq2(); + var gt = require_gt2(); + var gte = require_gte2(); + var lt = require_lt2(); + var lte = require_lte2(); + var cmp = (a, op, b, loose) => { + switch (op) { + case "===": + if (typeof a === "object") { + a = a.version; + } + if (typeof b === "object") { + b = b.version; + } + return a === b; + case "!==": + if (typeof a === "object") { + a = a.version; + } + if (typeof b === "object") { + b = b.version; + } + return a !== b; + case "": + case "=": + case "==": + return eq(a, b, loose); + case "!=": + return neq(a, b, loose); + case ">": + return gt(a, b, loose); + case ">=": + return gte(a, b, loose); + case "<": + return lt(a, b, loose); + case "<=": + return lte(a, b, loose); + default: + throw new TypeError(`Invalid operator: ${op}`); + } + }; + module2.exports = cmp; +}); + +// node_modules/semver/classes/comparator.js +var require_comparator2 = __commonJS((exports2, module2) => { + var ANY = Symbol("SemVer ANY"); + var Comparator = class { + static get ANY() { + return ANY; + } + constructor(comp, options) { + options = parseOptions(options); + if (comp instanceof Comparator) { + if (comp.loose === !!options.loose) { + return comp; + } else { + comp = comp.value; + } + } + debug2("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; + } + debug2("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] !== void 0 ? m[1] : ""; + if (this.operator === "=") { + this.operator = ""; + } + if (!m[2]) { + this.semver = ANY; + } else { + this.semver = new SemVer(m[2], this.options.loose); + } + } + toString() { + return this.value; + } + test(version) { + debug2("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; + } + }; + module2.exports = Comparator; + var parseOptions = require_parse_options2(); + var {re, t} = require_re2(); + var cmp = require_cmp2(); + var debug2 = require_debug2(); + var SemVer = require_semver4(); + var Range = require_range2(); +}); + +// node_modules/semver/classes/range.js +var require_range2 = __commonJS((exports2, module2) => { + var Range = class { + constructor(range, options) { + options = parseOptions(options); + if (range instanceof Range) { + if (range.loose === !!options.loose && range.includePrerelease === !!options.includePrerelease) { + return range; + } else { + return new Range(range.raw, options); + } + } + if (range instanceof Comparator) { + this.raw = range.value; + this.set = [[range]]; + this.format(); + return this; + } + this.options = options; + this.loose = !!options.loose; + this.includePrerelease = !!options.includePrerelease; + this.raw = range; + this.set = range.split("||").map((r) => this.parseRange(r.trim())).filter((c) => c.length); + if (!this.set.length) { + throw new TypeError(`Invalid SemVer Range: ${range}`); + } + if (this.set.length > 1) { + const first = this.set[0]; + this.set = this.set.filter((c) => !isNullSet(c[0])); + if (this.set.length === 0) { + this.set = [first]; + } else if (this.set.length > 1) { + for (const c of this.set) { + if (c.length === 1 && isAny(c[0])) { + this.set = [c]; + break; + } + } + } + } + this.format(); + } + format() { + this.range = this.set.map((comps) => { + return comps.join(" ").trim(); + }).join("||").trim(); + return this.range; + } + toString() { + return this.range; + } + parseRange(range) { + range = range.trim(); + const memoOpts = Object.keys(this.options).join(","); + const memoKey = `parseRange:${memoOpts}:${range}`; + const cached = cache.get(memoKey); + if (cached) { + return cached; + } + const loose = this.options.loose; + const hr = loose ? re[t.HYPHENRANGELOOSE] : re[t.HYPHENRANGE]; + range = range.replace(hr, hyphenReplace(this.options.includePrerelease)); + debug2("hyphen replace", range); + range = range.replace(re[t.COMPARATORTRIM], comparatorTrimReplace); + debug2("comparator trim", range); + range = range.replace(re[t.TILDETRIM], tildeTrimReplace); + range = range.replace(re[t.CARETTRIM], caretTrimReplace); + range = range.split(/\s+/).join(" "); + let rangeList = range.split(" ").map((comp) => parseComparator(comp, this.options)).join(" ").split(/\s+/).map((comp) => replaceGTE0(comp, this.options)); + if (loose) { + rangeList = rangeList.filter((comp) => { + debug2("loose invalid filter", comp, this.options); + return !!comp.match(re[t.COMPARATORLOOSE]); + }); + } + debug2("range list", rangeList); + const rangeMap = new Map(); + const comparators = rangeList.map((comp) => new Comparator(comp, this.options)); + for (const comp of comparators) { + if (isNullSet(comp)) { + return [comp]; + } + rangeMap.set(comp.value, comp); + } + if (rangeMap.size > 1 && rangeMap.has("")) { + rangeMap.delete(""); + } + const result = [...rangeMap.values()]; + cache.set(memoKey, result); + return result; + } + intersects(range, options) { + if (!(range instanceof Range)) { + throw new TypeError("a Range is required"); + } + return this.set.some((thisComparators) => { + return isSatisfiable(thisComparators, options) && range.set.some((rangeComparators) => { + return isSatisfiable(rangeComparators, options) && thisComparators.every((thisComparator) => { + return rangeComparators.every((rangeComparator) => { + return thisComparator.intersects(rangeComparator, options); + }); + }); + }); + }); + } + test(version) { + if (!version) { + return false; + } + if (typeof version === "string") { + try { + version = new SemVer(version, this.options); + } catch (er) { + return false; + } + } + for (let i = 0; i < this.set.length; i++) { + if (testSet(this.set[i], version, this.options)) { + return true; + } + } + return false; + } + }; + module2.exports = Range; + var LRU = require_lru_cache(); + var cache = new LRU({max: 1e3}); + var parseOptions = require_parse_options2(); + var Comparator = require_comparator2(); + var debug2 = require_debug2(); + var SemVer = require_semver4(); + var { + re, + t, + comparatorTrimReplace, + tildeTrimReplace, + caretTrimReplace + } = require_re2(); + var isNullSet = (c) => c.value === "<0.0.0-0"; + var isAny = (c) => c.value === ""; + var isSatisfiable = (comparators, options) => { + let result = true; + const remainingComparators = comparators.slice(); + let testComparator = remainingComparators.pop(); + while (result && remainingComparators.length) { + result = remainingComparators.every((otherComparator) => { + return testComparator.intersects(otherComparator, options); + }); + testComparator = remainingComparators.pop(); + } + return result; + }; + var parseComparator = (comp, options) => { + debug2("comp", comp, options); + comp = replaceCarets(comp, options); + debug2("caret", comp); + comp = replaceTildes(comp, options); + debug2("tildes", comp); + comp = replaceXRanges(comp, options); + debug2("xrange", comp); + comp = replaceStars(comp, options); + debug2("stars", comp); + return comp; + }; + var isX = (id) => !id || id.toLowerCase() === "x" || id === "*"; + var replaceTildes = (comp, options) => comp.trim().split(/\s+/).map((c) => { + return replaceTilde(c, options); + }).join(" "); + var replaceTilde = (comp, options) => { + const r = options.loose ? re[t.TILDELOOSE] : re[t.TILDE]; + return comp.replace(r, (_, M, m, p, pr) => { + debug2("tilde", comp, _, M, m, p, pr); + let ret; + if (isX(M)) { + ret = ""; + } else if (isX(m)) { + ret = `>=${M}.0.0 <${+M + 1}.0.0-0`; + } else if (isX(p)) { + ret = `>=${M}.${m}.0 <${M}.${+m + 1}.0-0`; + } else if (pr) { + debug2("replaceTilde pr", pr); + ret = `>=${M}.${m}.${p}-${pr} <${M}.${+m + 1}.0-0`; + } else { + ret = `>=${M}.${m}.${p} <${M}.${+m + 1}.0-0`; + } + debug2("tilde return", ret); + return ret; + }); + }; + var replaceCarets = (comp, options) => comp.trim().split(/\s+/).map((c) => { + return replaceCaret(c, options); + }).join(" "); + var replaceCaret = (comp, options) => { + debug2("caret", comp, options); + const r = options.loose ? re[t.CARETLOOSE] : re[t.CARET]; + const z = options.includePrerelease ? "-0" : ""; + return comp.replace(r, (_, M, m, p, pr) => { + debug2("caret", comp, _, M, m, p, pr); + let ret; + if (isX(M)) { + ret = ""; + } else if (isX(m)) { + ret = `>=${M}.0.0${z} <${+M + 1}.0.0-0`; + } else if (isX(p)) { + if (M === "0") { + ret = `>=${M}.${m}.0${z} <${M}.${+m + 1}.0-0`; + } else { + ret = `>=${M}.${m}.0${z} <${+M + 1}.0.0-0`; + } + } else if (pr) { + debug2("replaceCaret pr", pr); + if (M === "0") { + if (m === "0") { + ret = `>=${M}.${m}.${p}-${pr} <${M}.${m}.${+p + 1}-0`; + } else { + ret = `>=${M}.${m}.${p}-${pr} <${M}.${+m + 1}.0-0`; + } + } else { + ret = `>=${M}.${m}.${p}-${pr} <${+M + 1}.0.0-0`; + } + } else { + debug2("no pr"); + if (M === "0") { + if (m === "0") { + ret = `>=${M}.${m}.${p}${z} <${M}.${m}.${+p + 1}-0`; + } else { + ret = `>=${M}.${m}.${p}${z} <${M}.${+m + 1}.0-0`; + } + } else { + ret = `>=${M}.${m}.${p} <${+M + 1}.0.0-0`; + } + } + debug2("caret return", ret); + return ret; + }); + }; + var replaceXRanges = (comp, options) => { + debug2("replaceXRanges", comp, options); + return comp.split(/\s+/).map((c) => { + return replaceXRange(c, options); + }).join(" "); + }; + var replaceXRange = (comp, options) => { + comp = comp.trim(); + const r = options.loose ? re[t.XRANGELOOSE] : re[t.XRANGE]; + return comp.replace(r, (ret, gtlt, M, m, p, pr) => { + debug2("xRange", comp, ret, gtlt, M, m, p, pr); + const xM = isX(M); + const xm = xM || isX(m); + const xp = xm || isX(p); + const anyX = xp; + if (gtlt === "=" && anyX) { + gtlt = ""; + } + pr = options.includePrerelease ? "-0" : ""; + if (xM) { + if (gtlt === ">" || gtlt === "<") { + ret = "<0.0.0-0"; + } else { + ret = "*"; + } + } else if (gtlt && anyX) { + if (xm) { + m = 0; + } + p = 0; + if (gtlt === ">") { + gtlt = ">="; + if (xm) { + M = +M + 1; + m = 0; + p = 0; + } else { + m = +m + 1; + p = 0; + } + } else if (gtlt === "<=") { + gtlt = "<"; + if (xm) { + M = +M + 1; + } else { + m = +m + 1; + } + } + if (gtlt === "<") { + pr = "-0"; + } + ret = `${gtlt + M}.${m}.${p}${pr}`; + } else if (xm) { + ret = `>=${M}.0.0${pr} <${+M + 1}.0.0-0`; + } else if (xp) { + ret = `>=${M}.${m}.0${pr} <${M}.${+m + 1}.0-0`; + } + debug2("xRange return", ret); + return ret; + }); + }; + var replaceStars = (comp, options) => { + debug2("replaceStars", comp, options); + return comp.trim().replace(re[t.STAR], ""); + }; + var replaceGTE0 = (comp, options) => { + debug2("replaceGTE0", comp, options); + return comp.trim().replace(re[options.includePrerelease ? t.GTE0PRE : t.GTE0], ""); + }; + var hyphenReplace = (incPr) => ($0, from, fM, fm, fp, fpr, fb, to, tM, tm, tp, tpr, tb) => { + if (isX(fM)) { + from = ""; + } else if (isX(fm)) { + from = `>=${fM}.0.0${incPr ? "-0" : ""}`; + } else if (isX(fp)) { + from = `>=${fM}.${fm}.0${incPr ? "-0" : ""}`; + } else if (fpr) { + from = `>=${from}`; + } else { + from = `>=${from}${incPr ? "-0" : ""}`; + } + if (isX(tM)) { + to = ""; + } else if (isX(tm)) { + to = `<${+tM + 1}.0.0-0`; + } else if (isX(tp)) { + to = `<${tM}.${+tm + 1}.0-0`; + } else if (tpr) { + to = `<=${tM}.${tm}.${tp}-${tpr}`; + } else if (incPr) { + to = `<${tM}.${tm}.${+tp + 1}-0`; + } else { + to = `<=${to}`; + } + return `${from} ${to}`.trim(); + }; + var testSet = (set, version, options) => { + for (let i = 0; i < set.length; i++) { + if (!set[i].test(version)) { + return false; + } + } + if (version.prerelease.length && !options.includePrerelease) { + for (let i = 0; i < set.length; i++) { + debug2(set[i].semver); + if (set[i].semver === Comparator.ANY) { + continue; + } + if (set[i].semver.prerelease.length > 0) { + const allowed = set[i].semver; + if (allowed.major === version.major && allowed.minor === version.minor && allowed.patch === version.patch) { + return true; + } + } + } + return false; + } + return true; + }; +}); + +// node_modules/semver/ranges/intersects.js +var require_intersects2 = __commonJS((exports2, module2) => { + var Range = require_range2(); + var intersects = (r1, r2, options) => { + r1 = new Range(r1, options); + r2 = new Range(r2, options); + return r1.intersects(r2); + }; + module2.exports = intersects; +}); + // src/setup-pdm.ts var core3 = __toModule(require_core()); var exec3 = __toModule(require_exec()); @@ -6655,22 +7581,27 @@ async function findPythonVersion(version, architecture) { // src/setup-pdm.ts var os2 = __toModule(require("os")); -var import_child_process = __toModule(require("child_process")); var import_fs2 = __toModule(require("fs")); var import_path = __toModule(require("path")); -var INSTALL_VERSION = "3.8"; +var import_parse = __toModule(require_parse2()); +var import_intersects = __toModule(require_intersects2()); +var PDM_PYTHON_REQUIRES = ">=3.7"; +var FALLBACK_INSTALL_VERSION = "3.10"; var GITHUB_REPO = "https://github.com/pdm-project/pdm.git"; -function getPep582Path() { +function getPep582Path(version) { const installDir = process.env.pythonLocation || ""; + const parsedVersion = (0, import_parse.default)(version); if (IS_WINDOWS) { return import_path.default.resolve(installDir, "Lib/site-packages/pdm/pep582"); } else { - return import_path.default.resolve(installDir, "lib", `python${INSTALL_VERSION}`, "site-packages/pdm/pep582"); + return import_path.default.resolve(installDir, "lib", `python${parsedVersion.major}.${parsedVersion.minor}`, "site-packages/pdm/pep582"); } } async function run() { const arch2 = core3.getInput("architecture") || os2.arch(); const pdmVersion = core3.getInput("version"); + const pythonVersion = core3.getInput("python-version"); + const versionCompatible = (0, import_intersects.default)(PDM_PYTHON_REQUIRES, pythonVersion); const ref = core3.getInput("ref"); const pdmPackage = pdmVersion ? `pdm==${pdmVersion}` : ref ? `pdm @ git+${GITHUB_REPO}@${ref}` : "pdm"; const cmdArgs = ["-m", "pip", "install", "-U", pdmPackage]; @@ -6678,23 +7609,23 @@ async function run() { cmdArgs.push("--pre"); } try { - let installedPython = await findPythonVersion(INSTALL_VERSION, arch2); + let installedPython = await findPythonVersion(versionCompatible ? pythonVersion : FALLBACK_INSTALL_VERSION, arch2); await exec3.exec("python", cmdArgs); if (core3.getInput("enable-pep582") === "true") { - core3.exportVariable("PYTHONPATH", getPep582Path()); + core3.exportVariable("PYTHONPATH", getPep582Path(installedPython.version)); } - if (core3.getInput("python-version") !== INSTALL_VERSION) { - installedPython = await findPythonVersion(core3.getInput("python-version"), arch2); + if (!versionCompatible) { + installedPython = await findPythonVersion(pythonVersion, arch2); } const pythonBin = import_path.default.join(process.env.pythonLocation, IS_WINDOWS ? "python.exe" : "bin/python").replace(/\\/g, "/"); await import_fs2.promises.writeFile(".pdm.toml", `[python] path="${pythonBin}" `); - const pdmVersionOutput = (await (0, import_child_process.exec)("pdm --version")).stdout; + const {stdout: pdmVersionOutput} = await exec3.getExecOutput("pdm --version"); if (process.platform === "linux") { core3.exportVariable("LD_PRELOAD", "/lib/x86_64-linux-gnu/libgcc_s.so.1"); } - core3.info(`Successfully setup ${pdmVersionOutput && pdmVersionOutput.read()} with Python ${installedPython.version}`); + core3.info(`Successfully setup ${pdmVersionOutput} with Python ${installedPython.version}`); const matchersPath = import_path.default.join(__dirname, "..", ".github"); core3.info(`##[add-matcher]${import_path.default.join(matchersPath, "python.json")}`); } catch (error2) { diff --git a/package.json b/package.json index af89e61..bdbc5fb 100644 --- a/package.json +++ b/package.json @@ -13,6 +13,7 @@ "dependencies": { "@actions/core": "^1.2.6", "@actions/exec": "^1.0.4", + "semver": "^7.3.7", "setup-python": "actions/setup-python" }, "devDependencies": { diff --git a/src/setup-pdm.ts b/src/setup-pdm.ts index c3755b4..9d5badd 100644 --- a/src/setup-pdm.ts +++ b/src/setup-pdm.ts @@ -1,79 +1,60 @@ -import * as core from "@actions/core"; -import * as exec from "@actions/exec"; -import * as setupPython from "setup-python/src/find-python"; -import { IS_WINDOWS } from "setup-python/src/utils"; -import * as os from "os"; -import { exec as execChild } from "child_process"; -import { promises as fs } from "fs"; -import path from "path"; +import * as core from '@actions/core' +import * as exec from '@actions/exec' +import * as setupPython from 'setup-python/src/find-python' +import { IS_WINDOWS } from 'setup-python/src/utils' +import * as os from 'os' +import { promises as fs } from 'fs' +import path from 'path' +import semParse from 'semver/functions/parse' +import semIntersect from 'semver/ranges/intersects' -const INSTALL_VERSION = "3.8"; -const GITHUB_REPO = "https://github.com/pdm-project/pdm.git"; +const PDM_PYTHON_REQUIRES = '>=3.7' +const FALLBACK_INSTALL_VERSION = '3.10' +const GITHUB_REPO = 'https://github.com/pdm-project/pdm.git' -function getPep582Path(): string { - const installDir = process.env.pythonLocation || ""; +function getPep582Path(version: string): string { + const installDir = process.env.pythonLocation || '' + const parsedVersion = semParse(version)! if (IS_WINDOWS) { - return path.resolve(installDir, "Lib/site-packages/pdm/pep582"); + return path.resolve(installDir, 'Lib/site-packages/pdm/pep582') } else { - return path.resolve( - installDir, - "lib", - `python${INSTALL_VERSION}`, - "site-packages/pdm/pep582" - ); + return path.resolve(installDir, 'lib', `python${parsedVersion.major}.${parsedVersion.minor}`, 'site-packages/pdm/pep582') } } async function run(): Promise { - const arch = core.getInput("architecture") || os.arch(); - const pdmVersion = core.getInput("version"); - const ref = core.getInput("ref"); - const pdmPackage = pdmVersion - ? `pdm==${pdmVersion}` - : ref - ? `pdm @ git+${GITHUB_REPO}@${ref}` - : "pdm"; - const cmdArgs = ["-m", "pip", "install", "-U", pdmPackage]; - if (core.getInput("prerelease") === "true") { - cmdArgs.push("--pre"); + const arch = core.getInput('architecture') || os.arch() + const pdmVersion = core.getInput('version') + const pythonVersion = core.getInput('python-version') + const versionCompatible = semIntersect(PDM_PYTHON_REQUIRES, pythonVersion) + const ref = core.getInput('ref') + const pdmPackage = pdmVersion ? `pdm==${pdmVersion}` : ref ? `pdm @ git+${GITHUB_REPO}@${ref}` : 'pdm' + const cmdArgs = ['-m', 'pip', 'install', '-U', pdmPackage] + if (core.getInput('prerelease') === 'true') { + cmdArgs.push('--pre') } try { - let installedPython = await setupPython.findPythonVersion( - INSTALL_VERSION, - arch - ); - await exec.exec("python", cmdArgs); - if (core.getInput("enable-pep582") === "true") { - core.exportVariable("PYTHONPATH", getPep582Path()); + let installedPython = await setupPython.findPythonVersion(versionCompatible ? pythonVersion : FALLBACK_INSTALL_VERSION, arch) + await exec.exec('python', cmdArgs) + if (core.getInput('enable-pep582') === 'true') { + core.exportVariable('PYTHONPATH', getPep582Path(installedPython.version)) } - if (core.getInput("python-version") !== INSTALL_VERSION) { - installedPython = await setupPython.findPythonVersion( - core.getInput("python-version"), - arch - ); + if (!versionCompatible) { + installedPython = await setupPython.findPythonVersion(pythonVersion, arch) } - const pythonBin = path - .join( - process.env.pythonLocation as string, - IS_WINDOWS ? "python.exe" : "bin/python" - ) - .replace(/\\/g, "/"); - await fs.writeFile(".pdm.toml", `[python]\npath="${pythonBin}"\n`); - const pdmVersionOutput = (await execChild("pdm --version")).stdout; - if (process.platform === "linux") { + const pythonBin = path.join(process.env.pythonLocation as string, IS_WINDOWS ? 'python.exe' : 'bin/python').replace(/\\/g, '/') + await fs.writeFile('.pdm.toml', `[python]\npath="${pythonBin}"\n`) + const { stdout: pdmVersionOutput } = await exec.getExecOutput('pdm --version') + if (process.platform === 'linux') { // See https://github.com/actions/virtual-environments/issues/2803 - core.exportVariable("LD_PRELOAD", "/lib/x86_64-linux-gnu/libgcc_s.so.1"); + core.exportVariable('LD_PRELOAD', '/lib/x86_64-linux-gnu/libgcc_s.so.1') } - core.info( - `Successfully setup ${ - pdmVersionOutput && pdmVersionOutput.read() - } with Python ${installedPython.version}` - ); - const matchersPath = path.join(__dirname, "..", ".github"); - core.info(`##[add-matcher]${path.join(matchersPath, "python.json")}`); + core.info(`Successfully setup ${pdmVersionOutput} with Python ${installedPython.version}`) + const matchersPath = path.join(__dirname, '..', '.github') + core.info(`##[add-matcher]${path.join(matchersPath, 'python.json')}`) } catch (error: any) { - core.setFailed(error.message); + core.setFailed(error.message) } } -run(); +run()