renovate
Version:
Automated dependency updates. Flexible so you don't need to be.
217 lines (216 loc) • 8.88 kB
JavaScript
import { newlineRegex, regEx } from "../../../util/regex.js";
import { logger } from "../../../logger/index.js";
import { isHttpUrl } from "../../../util/url.js";
import { readLocalFile } from "../../../util/fs/index.js";
import { GitRefsDatasource } from "../../datasource/git-refs/index.js";
import { RubyVersionDatasource } from "../../datasource/ruby-version/index.js";
import { RubygemsDatasource } from "../../datasource/rubygems/index.js";
import { delimiters, extractRubyVersion, getLockFilePath } from "./common.js";
import { extractLockFileEntries } from "./locked-version.js";
import { isString } from "@sindresorhus/is";
//#region lib/modules/manager/bundler/extract.ts
function formatContent(input) {
return `${input.replace(regEx(/^ {2}/), "")}\n`;
}
const variableMatchRegex = regEx(`^(?<key>\\w+)\\s*=\\s*['"](?<value>[^'"]+)['"]`);
const gemMatchRegex = regEx(`^\\s*gem\\s+(['"])(?<depName>[^'"]+)(['"])(\\s*,\\s*(?<currentValue>(['"])[^'"]+['"](\\s*,\\s*['"][^'"]+['"])?))?`);
const sourceMatchRegex = regEx(`source:\\s*((?:['"](?<registryUrl>[^'"]+)['"])|(?<sourceName>\\w+))?`);
const gitRefsMatchRegex = regEx(`((git:\\s*['"](?<gitUrl>[^'"]+)['"])|(\\s*,\\s*github:\\s*['"](?<repoName>[^'"]+)['"]))(\\s*,\\s*branch:\\s*['"](?<branchName>[^'"]+)['"])?(\\s*,\\s*ref:\\s*['"](?<refName>[^'"]+)['"])?(\\s*,\\s*tag:\\s*['"](?<tagName>[^'"]+)['"])?`);
const pathMatchRegex = regEx(`path:\\s*['"](?<path>[^'"]+)['"]`);
async function extractPackageFile(content, packageFile) {
let lineNumber;
async function processGroupBlock(line, repositoryUrl, trimGroupLine = false) {
const groupMatch = regEx(/^group\s+(.*?)\s+do/).exec(line);
if (groupMatch) {
const depTypes = groupMatch[1].split(",").map((group) => group.trim()).map((group) => group.replace(regEx(/^:/), ""));
const groupLineNumber = lineNumber;
let groupContent = "";
let groupLine = "";
while (lineNumber < lines.length && (trimGroupLine ? groupLine.trim() !== "end" : groupLine !== "end")) {
lineNumber += 1;
groupLine = lines[lineNumber];
// istanbul ignore if
if (!isString(groupLine)) {
logger.debug({
content,
packageFile,
type: "groupLine"
}, "Bundler parsing error");
groupLine = "end";
}
if (trimGroupLine ? groupLine.trim() !== "end" : groupLine !== "end") groupContent += formatContent(groupLine);
}
const groupRes = await extractPackageFile(groupContent);
if (groupRes) res.deps = res.deps.concat(groupRes.deps.map((dep) => {
const depObject = {
...dep,
depTypes,
managerData: { lineNumber: Number(dep.managerData?.lineNumber) + groupLineNumber + 1 }
};
if (repositoryUrl) depObject.registryUrls = [repositoryUrl];
return depObject;
}));
}
}
const res = {
registryUrls: [],
deps: []
};
const variables = {};
const lines = content.split(newlineRegex);
for (lineNumber = 0; lineNumber < lines.length; lineNumber += 1) {
const line = lines[lineNumber];
let sourceMatch = null;
for (const delimiter of delimiters) sourceMatch = sourceMatch ?? regEx(`^source ((${delimiter}(?<registryUrl>[^${delimiter}]+)${delimiter})|(?<sourceName>\\w+))\\s*$`).exec(line);
if (sourceMatch) {
if (sourceMatch.groups?.registryUrl) res.registryUrls?.push(sourceMatch.groups.registryUrl);
if (sourceMatch.groups?.sourceName) {
const registryUrl = variables[sourceMatch.groups.sourceName];
if (registryUrl) res.registryUrls?.push(registryUrl);
}
}
const rubyMatch = extractRubyVersion(line);
if (rubyMatch) res.deps.push({
depName: "ruby",
currentValue: rubyMatch,
datasource: RubyVersionDatasource.id,
registryUrls: null
});
const variableMatch = variableMatchRegex.exec(line);
if (variableMatch) {
if (variableMatch.groups?.key) variables[variableMatch.groups?.key] = variableMatch.groups?.value;
}
const gemMatch = gemMatchRegex.exec(line)?.groups;
if (gemMatch) {
const dep = {
depName: gemMatch.depName,
managerData: { lineNumber },
datasource: RubygemsDatasource.id
};
if (gemMatch.currentValue) dep.currentValue = gemMatch.currentValue;
if (pathMatchRegex.exec(line)?.groups) dep.skipReason = "internal-package";
const sourceMatch = sourceMatchRegex.exec(line)?.groups;
if (sourceMatch) {
if (sourceMatch.registryUrl) dep.registryUrls = [sourceMatch.registryUrl];
else if (sourceMatch.sourceName) dep.registryUrls = [variables[sourceMatch.sourceName]];
}
const gitRefsMatch = gitRefsMatchRegex.exec(line)?.groups;
if (gitRefsMatch) {
if (gitRefsMatch.gitUrl) {
const gitUrl = gitRefsMatch.gitUrl;
dep.packageName = gitUrl;
if (isHttpUrl(gitUrl)) dep.sourceUrl = gitUrl.replace(/\.git$/, "");
} else if (gitRefsMatch.repoName) {
dep.packageName = `https://github.com/${gitRefsMatch.repoName}`;
dep.sourceUrl = dep.packageName;
}
if (gitRefsMatch.refName) dep.currentDigest = gitRefsMatch.refName;
else if (gitRefsMatch.branchName) dep.currentValue = gitRefsMatch.branchName;
else if (gitRefsMatch.tagName) dep.currentValue = gitRefsMatch.tagName;
dep.datasource = GitRefsDatasource.id;
}
res.deps.push(dep);
}
await processGroupBlock(line);
for (const delimiter of delimiters) {
const sourceBlockMatch = regEx(`^source\\s+((${delimiter}(?<registryUrl>[^${delimiter}]+)${delimiter})|(?<sourceName>\\w+))\\s+do`).exec(line);
if (sourceBlockMatch) {
let repositoryUrl = "";
if (sourceBlockMatch.groups?.registryUrl) repositoryUrl = sourceBlockMatch.groups.registryUrl;
if (sourceBlockMatch.groups?.sourceName) {
if (variables[sourceBlockMatch.groups.sourceName]) repositoryUrl = variables[sourceBlockMatch.groups.sourceName];
}
const sourceLineNumber = lineNumber;
let sourceContent = "";
let sourceLine = "";
while (lineNumber < lines.length && sourceLine.trim() !== "end") {
lineNumber += 1;
sourceLine = lines[lineNumber];
// istanbul ignore if
if (!isString(sourceLine)) {
logger.debug({
content,
packageFile,
type: "sourceLine"
}, "Bundler parsing error");
sourceLine = "end";
}
await processGroupBlock(sourceLine.trim(), repositoryUrl, true);
if (sourceLine.trim() !== "end") sourceContent += formatContent(sourceLine);
}
const sourceRes = await extractPackageFile(sourceContent);
if (sourceRes) res.deps = res.deps.concat(sourceRes.deps.map((dep) => ({
...dep,
registryUrls: [repositoryUrl],
managerData: { lineNumber: Number(dep.managerData?.lineNumber) + sourceLineNumber + 1 }
})));
}
}
if (regEx(/^platforms\s+(.*?)\s+do/).test(line)) {
const platformsLineNumber = lineNumber;
let platformsContent = "";
let platformsLine = "";
while (lineNumber < lines.length && platformsLine !== "end") {
lineNumber += 1;
platformsLine = lines[lineNumber];
// istanbul ignore if
if (!isString(platformsLine)) {
logger.debug({
content,
packageFile,
type: "platformsLine"
}, "Bundler parsing error");
platformsLine = "end";
}
if (platformsLine !== "end") platformsContent += formatContent(platformsLine);
}
const platformsRes = await extractPackageFile(platformsContent);
if (platformsRes) res.deps = res.deps.concat(platformsRes.deps.map((dep) => ({
...dep,
managerData: { lineNumber: Number(dep.managerData?.lineNumber) + platformsLineNumber + 1 }
})));
}
if (regEx(/^if\s+(.*?)/).test(line)) {
const ifLineNumber = lineNumber;
let ifContent = "";
let ifLine = "";
while (lineNumber < lines.length && ifLine !== "end") {
lineNumber += 1;
ifLine = lines[lineNumber];
// istanbul ignore if
if (!isString(ifLine)) {
logger.debug({
content,
packageFile,
type: "ifLine"
}, "Bundler parsing error");
ifLine = "end";
}
if (ifLine !== "end") ifContent += formatContent(ifLine);
}
const ifRes = await extractPackageFile(ifContent);
if (ifRes) res.deps = res.deps.concat(ifRes.deps.map((dep) => ({
...dep,
managerData: { lineNumber: Number(dep.managerData?.lineNumber) + ifLineNumber + 1 }
})));
}
}
if (!res.deps.length && !res.registryUrls?.length) return null;
if (packageFile) {
const gemfileLockPath = await getLockFilePath(packageFile);
const lockContent = await readLocalFile(gemfileLockPath, "utf8");
if (lockContent) {
logger.debug(`Found lock file ${gemfileLockPath} for packageFile: ${packageFile}`);
res.lockFiles = [gemfileLockPath];
const lockedEntries = extractLockFileEntries(lockContent);
for (const dep of res.deps) {
const lockedDepValue = lockedEntries.get(`${dep.depName}`);
if (lockedDepValue) dep.lockedVersion = lockedDepValue;
}
}
}
return res;
}
//#endregion
export { extractPackageFile };
//# sourceMappingURL=extract.js.map