release-please 12.3.0 → 13.0.0-candidate.0

package/build/src/plugins/cargo-workspace.js

@@ -13,370 +13,289 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.postOrder = void 0;
-const semver = require("semver");
-const conventional_commits_1 = require("../conventional-commits");
-const changelog_1 = require("../updaters/changelog");
-const cargo_lock_1 = require("../updaters/rust/cargo-lock");
-const cargo_toml_1 = require("../updaters/rust/cargo-toml");
+exports.CargoWorkspace = void 0;
+const manifest_1 = require("../manifest");
+const logger_1 = require("../util/logger");
+const workspace_1 = require("./workspace");
 const common_1 = require("../updaters/rust/common");
-const checkpoint_1 = require("../util/checkpoint");
-const plugin_1 = require("./plugin");
-class CargoWorkspaceDependencyUpdates extends plugin_1.ManifestPlugin {
-    async getWorkspaceManifest() {
-        const content = await this.gh.getFileContents('Cargo.toml');
-        return common_1.parseCargoManifest(content.parsedContent);
+const version_1 = require("../version");
+const cargo_toml_1 = require("../updaters/rust/cargo-toml");
+const raw_content_1 = require("../updaters/raw-content");
+const changelog_1 = require("../updaters/changelog");
+const pull_request_title_1 = require("../util/pull-request-title");
+const pull_request_body_1 = require("../util/pull-request-body");
+const branch_name_1 = require("../util/branch-name");
+/**
+ * The plugin analyzed a cargo workspace and will bump dependencies
+ * of managed packages if those dependencies are being updated.
+ *
+ * If multiple rust packages are being updated, it will merge them
+ * into a single rust package.
+ */
+class CargoWorkspace extends workspace_1.WorkspacePlugin {
+    constructor(github, targetBranch, repositoryConfig, options = {}) {
+        super(github, targetBranch, repositoryConfig, {
+            ...options,
+            updateAllPackages: true,
+        });
     }
-    async run(newManifestVersions, pkgsWithPRData) {
-        const workspaceManifest = await this.getWorkspaceManifest();
-        if (!workspaceManifest.workspace) {
-            throw new Error("cargo-workspace plugin used, but top-level Cargo.toml isn't a cargo workspace");
-        }
-        if (!workspaceManifest.workspace.members) {
-            throw new Error('cargo-workspace plugin used, but top-level Cargo.toml has no members');
+    async buildAllPackages(candidates) {
+        var _a, _b, _c, _d;
+        const cargoManifestContent = await this.github.getFileContentsOnBranch('Cargo.toml', this.targetBranch);
+        const cargoManifest = common_1.parseCargoManifest(cargoManifestContent.parsedContent);
+        if (!((_a = cargoManifest.workspace) === null || _a === void 0 ? void 0 : _a.members)) {
+            logger_1.logger.warn("cargo-workspace plugin used, but top-level Cargo.toml isn't a cargo workspace");
+            return { allPackages: [], candidatesByPackage: {} };
         }
-        const crateInfos = await this.getAllCrateInfos(workspaceManifest.workspace.members, pkgsWithPRData);
-        const crateInfoMap = new Map(crateInfos.map(crate => [crate.name, crate]));
-        const crateGraph = buildCrateGraph(crateInfoMap);
-        const order = postOrder(crateGraph);
-        const orderedCrates = order.map(name => crateInfoMap.get(name));
-        const versions = new Map();
-        for (const data of pkgsWithPRData) {
-            if (data.config.releaseType !== 'rust' || data.config.path === '.') {
-                continue;
+        const allCrates = [];
+        const candidatesByPackage = {};
+        for (const path of cargoManifest.workspace.members) {
+            const manifestPath = addPath(path, 'Cargo.toml');
+            logger_1.logger.info(`looking for candidate with path: ${path}`);
+            const candidate = candidates.find(c => c.path === path);
+            // get original content of the crate
+            const manifestContent = ((_b = candidate === null || candidate === void 0 ? void 0 : candidate.pullRequest.updates.find(update => update.path === manifestPath)) === null || _b === void 0 ? void 0 : _b.cachedFileContents) ||
+                (await this.github.getFileContentsOnBranch(manifestPath, this.targetBranch));
+            const manifest = common_1.parseCargoManifest(manifestContent.parsedContent);
+            const packageName = (_c = manifest.package) === null || _c === void 0 ? void 0 : _c.name;
+            if (!packageName) {
+                throw new Error(`package manifest at ${manifestPath} is missing [package.name]`);
             }
-            versions.set(data.config.packageName, data.prData.version);
-        }
-        // Try to upgrade /all/ packages, even those release-please did not bump
-        for (const crate of orderedCrates) {
-            // This should update all the dependencies that have been bumped by release-please
-            const dependencyUpdates = new cargo_toml_1.CargoToml({
-                path: crate.manifestPath,
-                changelogEntry: 'updating dependencies',
-                version: 'unused',
-                versions,
-                packageName: 'unused',
-            });
-            let newContent = dependencyUpdates.updateContent(crate.manifestContent);
-            if (newContent === crate.manifestContent) {
-                // guess that package didn't depend on any of the bumped packages
-                continue;
+            if (candidate) {
+                candidatesByPackage[packageName] = candidate;
             }
-            let updatedManifest = {
-                content: newContent,
-                mode: '100644',
-            };
-            if (crate.manifestPkg) {
-                // package was already bumped by release-please, just update the change
-                // to also include dependency updates.
-                crate.manifestPkg.prData.changes.set(crate.manifestPath, updatedManifest);
-                await this.setChangelogEntry(crate.manifestPkg.config, crate.manifestPkg.prData.changes, crate.manifestContent, updatedManifest.content // bug if undefined
-                );
+            const version = (_d = manifest.package) === null || _d === void 0 ? void 0 : _d.version;
+            if (!version) {
+                throw new Error(`package manifest at ${manifestPath} is missing [package.version]`);
             }
-            else {
-                // package was not bumped by release-please, but let's bump it ourselves,
-                // because one of its dependencies was upgraded.
-                let version;
-                const patch = semver.inc(crate.version, 'patch');
-                if (patch === null) {
-                    this.log(`Don't know how to patch ${crate.path}'s version(${crate.version})`, checkpoint_1.CheckpointType.Failure);
-                    version = crate.version;
+            allCrates.push({
+                path,
+                name: packageName,
+                version,
+                manifest,
+                manifestContent: manifestContent.parsedContent,
+                manifestPath,
+            });
+        }
+        return {
+            allPackages: allCrates,
+            candidatesByPackage,
+        };
+    }
+    bumpVersion(pkg) {
+        const version = version_1.Version.parse(pkg.version);
+        version.patch += 1;
+        return version;
+    }
+    updateCandidate(existingCandidate, pkg, updatedVersions) {
+        const version = updatedVersions.get(pkg.name);
+        if (!version) {
+            throw new Error(`Didn't find updated version for ${pkg.name}`);
+        }
+        const updater = new cargo_toml_1.CargoToml({
+            version,
+            versionsMap: updatedVersions,
+        });
+        const updatedContent = updater.updateContent(pkg.manifestContent);
+        const originalManifest = common_1.parseCargoManifest(pkg.manifestContent);
+        const updatedManifest = common_1.parseCargoManifest(updatedContent);
+        const dependencyNotes = getChangelogDepsNotes(originalManifest, updatedManifest);
+        existingCandidate.pullRequest.updates =
+            existingCandidate.pullRequest.updates.map(update => {
+                if (update.path === addPath(existingCandidate.path, 'Cargo.toml')) {
+                    update.updater = new raw_content_1.RawContent(updatedContent);
                 }
-                else {
-                    version = patch;
+                else if (update.updater instanceof changelog_1.Changelog) {
+                    update.updater.changelogEntry = appendDependenciesSectionToChangelog(update.updater.changelogEntry, dependencyNotes);
                 }
-                // we need to reprocess its Cargo manifest to bump its own version
-                versions.set(crate.name, version);
-                newContent = dependencyUpdates.updateContent(crate.manifestContent);
-                updatedManifest = {
-                    content: newContent,
-                    mode: '100644',
-                };
-                const changes = new Map([[crate.manifestPath, updatedManifest]]);
-                newManifestVersions.set(crate.path, version);
-                const manifestPkg = {
-                    config: {
-                        releaseType: 'rust',
-                        packageName: crate.name,
-                        path: crate.path,
-                    },
-                    prData: {
-                        changes,
-                        version,
-                    },
-                };
-                pkgsWithPRData.push(manifestPkg);
-                await this.setChangelogEntry(manifestPkg.config, manifestPkg.prData.changes, crate.manifestContent, updatedManifest.content // bug if undefined
-                );
-            }
-        }
-        // Upgrade package.lock
-        {
-            const lockfilePath = 'Cargo.lock';
-            const dependencyUpdates = new cargo_lock_1.CargoLock({
-                path: lockfilePath,
-                changelogEntry: 'updating cargo lockfile',
-                version: 'unused',
-                versions,
-                packageName: 'unused',
+                return update;
             });
-            const oldContent = (await this.gh.getFileContents(lockfilePath))
-                .parsedContent;
-            const newContent = dependencyUpdates.updateContent(oldContent);
-            if (newContent !== oldContent) {
-                const changes = new Map([
-                    [
-                        lockfilePath,
-                        {
-                            content: newContent,
-                            mode: '100644',
-                        },
-                    ],
-                ]);
-                pkgsWithPRData.push({
-                    config: {
-                        path: '.',
-                        packageName: 'cargo workspace',
-                        releaseType: 'rust',
-                    },
-                    prData: {
-                        changes,
-                        version: 'lockfile maintenance',
-                    },
+        // append dependency notes
+        if (dependencyNotes) {
+            if (existingCandidate.pullRequest.body.releaseData.length > 0) {
+                existingCandidate.pullRequest.body.releaseData[0].notes =
+                    appendDependenciesSectionToChangelog(existingCandidate.pullRequest.body.releaseData[0].notes, dependencyNotes);
+            }
+            else {
+                existingCandidate.pullRequest.body.releaseData.push({
+                    component: pkg.name,
+                    version: existingCandidate.pullRequest.version,
+                    notes: appendDependenciesSectionToChangelog('', dependencyNotes),
                 });
             }
         }
-        return [newManifestVersions, pkgsWithPRData];
+        return existingCandidate;
     }
-    async setChangelogEntry(config, changes, originalManifestContent, updatedManifestContent) {
-        var _a, _b, _c, _d, _e, _f;
-        const originalManifest = common_1.parseCargoManifest(originalManifestContent);
-        const updatedManifest = common_1.parseCargoManifest(updatedManifestContent);
-        const depUpdateNotes = this.getChangelogDepsNotes(originalManifest, updatedManifest);
-        if (!depUpdateNotes) {
-            return;
+    newCandidate(pkg, updatedVersions) {
+        const version = updatedVersions.get(pkg.name);
+        if (!version) {
+            throw new Error(`Didn't find updated version for ${pkg.name}`);
         }
-        const cc = new conventional_commits_1.ConventionalCommits({
-            changelogSections: [{ type: 'deps', section: 'Dependencies' }],
-            commits: [
+        const updater = new cargo_toml_1.CargoToml({
+            version,
+            versionsMap: updatedVersions,
+        });
+        const updatedContent = updater.updateContent(pkg.manifestContent);
+        const originalManifest = common_1.parseCargoManifest(pkg.manifestContent);
+        const updatedManifest = common_1.parseCargoManifest(updatedContent);
+        const dependencyNotes = getChangelogDepsNotes(originalManifest, updatedManifest);
+        const pullRequest = {
+            title: pull_request_title_1.PullRequestTitle.ofTargetBranch(this.targetBranch),
+            body: new pull_request_body_1.PullRequestBody([
+                {
+                    component: pkg.name,
+                    version,
+                    notes: appendDependenciesSectionToChangelog('', dependencyNotes),
+                },
+            ]),
+            updates: [
                 {
-                    sha: '',
-                    message: 'deps: The following workspace dependencies were updated',
-                    files: [],
+                    path: addPath(pkg.path, 'Cargo.toml'),
+                    createIfMissing: false,
+                    updater: new raw_content_1.RawContent(updatedContent),
+                },
+                {
+                    path: addPath(pkg.path, 'CHANGELOG.md'),
+                    createIfMissing: false,
+                    updater: new changelog_1.Changelog({
+                        version,
+                        changelogEntry: dependencyNotes,
+                    }),
                 },
             ],
-            owner: this.gh.owner,
-            repository: this.gh.repo,
-            bumpMinorPreMajor: config.bumpMinorPreMajor,
-        });
-        let tagPrefix = config.packageName;
-        tagPrefix += '-v';
-        const originalVersion = (_b = (_a = originalManifest.package) === null || _a === void 0 ? void 0 : _a.version) !== null && _b !== void 0 ? _b : '?';
-        const updatedVersion = (_d = (_c = updatedManifest.package) === null || _c === void 0 ? void 0 : _c.version) !== null && _d !== void 0 ? _d : '?';
-        let changelogEntry = await cc.generateChangelogEntry({
-            version: updatedVersion,
-            currentTag: tagPrefix + updatedVersion,
-            previousTag: tagPrefix + originalVersion,
-        });
-        changelogEntry += depUpdateNotes;
-        let updatedChangelog;
-        let changelogPath = (_e = config.changelogPath) !== null && _e !== void 0 ? _e : 'CHANGELOG.md';
-        if (config.path !== '.') {
-            changelogPath = `${config.path}/${changelogPath}`;
-        }
-        const exChangelog = (_f = changes.get(changelogPath)) === null || _f === void 0 ? void 0 : _f.content;
-        if (exChangelog) {
-            updatedChangelog = this.updateChangelogEntry(exChangelog, changelogEntry, updatedManifest);
-        }
-        else {
-            updatedChangelog = await this.newChangelogEntry(changelogEntry, changelogPath, updatedManifest);
-        }
-        if (updatedChangelog) {
-            changes.set(changelogPath, {
-                content: updatedChangelog,
-                mode: '100644',
-            });
-        }
-    }
-    getChangelogDepsNotes(originalManifest, updatedManifest) {
-        var _a;
-        let depUpdateNotes = '';
-        const depTypes = [
-            'dependencies',
-            'dev-dependencies',
-            'build-dependencies',
-        ];
-        const depVer = (s) => {
-            if (s === undefined) {
-                return undefined;
-            }
-            if (typeof s === 'string') {
-                return s;
-            }
-            else {
-                return s.version;
-            }
+            labels: [],
+            headRefName: branch_name_1.BranchName.ofTargetBranch(this.targetBranch).toString(),
+            version,
+            draft: false,
         };
-        const getDepMap = (cargoDeps) => {
-            const result = {};
-            for (const [key, val] of Object.entries(cargoDeps)) {
-                const ver = depVer(val);
-                if (ver) {
-                    result[key] = ver;
-                }
-            }
-            return result;
+        return {
+            path: pkg.path,
+            pullRequest,
+            config: {
+                releaseType: 'rust',
+            },
         };
-        const updates = new Map();
-        for (const depType of depTypes) {
-            const depUpdates = [];
-            const pkgDepTypes = updatedManifest[depType];
-            if (pkgDepTypes === undefined) {
-                continue;
-            }
-            for (const [depName, currentDepVer] of Object.entries(getDepMap(pkgDepTypes))) {
-                const origDepVer = depVer((_a = originalManifest[depType]) === null || _a === void 0 ? void 0 : _a[depName]);
-                if (currentDepVer !== origDepVer) {
-                    depUpdates.push(`\n    * ${depName} bumped from ${origDepVer} to ${currentDepVer}`);
-                }
-            }
-            if (depUpdates.length > 0) {
-                updates.set(depType, depUpdates);
-            }
-        }
-        for (const [dt, notes] of updates) {
-            depUpdateNotes += `\n  * ${dt}`;
-            for (const note of notes) {
-                depUpdateNotes += note;
-            }
+    }
+    async buildGraph(allPackages) {
+        var _a, _b, _c;
+        const workspaceCrateNames = new Set(allPackages.map(crateInfo => crateInfo.name));
+        const graph = new Map();
+        for (const crateInfo of allPackages) {
+            const allDeps = Object.keys({
+                ...((_a = crateInfo.manifest.dependencies) !== null && _a !== void 0 ? _a : {}),
+                ...((_b = crateInfo.manifest['dev-dependencies']) !== null && _b !== void 0 ? _b : {}),
+                ...((_c = crateInfo.manifest['build-dependencies']) !== null && _c !== void 0 ? _c : {}),
+            });
+            const workspaceDeps = allDeps.filter(dep => workspaceCrateNames.has(dep));
+            graph.set(crateInfo.name, {
+                deps: workspaceDeps,
+                value: crateInfo,
+            });
         }
-        return depUpdateNotes;
+        return graph;
     }
-    updateChangelogEntry(exChangelog, changelogEntry, updatedManifest) {
-        var _a, _b, _c, _d;
-        const pkgVersion = (_b = (_a = updatedManifest.package) === null || _a === void 0 ? void 0 : _a.version) !== null && _b !== void 0 ? _b : '?';
-        const pkgName = (_d = (_c = updatedManifest.package) === null || _c === void 0 ? void 0 : _c.name) !== null && _d !== void 0 ? _d : '?';
-        changelogEntry = changelogEntry.replace(new RegExp(`^###? \\[${pkgVersion}\\].*### Dependencies`, 's'), '### Dependencies');
-        const match = exChangelog.match(new RegExp(`(?<before>^.*?###? \\[${pkgVersion}\\].*?\n)(?<after>###? [0-9[].*)`, 's'));
-        if (!match) {
-            this.log(`Appending update notes to end of changelog for ${pkgName}`, checkpoint_1.CheckpointType.Failure);
-            changelogEntry = `${exChangelog}\n\n\n${changelogEntry}`;
+    inScope(candidate) {
+        return (candidate.config.releaseType === 'rust' &&
+            candidate.path !== manifest_1.ROOT_PROJECT_PATH);
+    }
+    packageNameFromPackage(pkg) {
+        return pkg.name;
+    }
+}
+exports.CargoWorkspace = CargoWorkspace;
+function getChangelogDepsNotes(originalManifest, updatedManifest) {
+    var _a;
+    let depUpdateNotes = '';
+    const depTypes = [
+        'dependencies',
+        'dev-dependencies',
+        'build-dependencies',
+    ];
+    const depVer = (s) => {
+        if (s === undefined) {
+            return undefined;
         }
-        else {
-            const { before, after } = match.groups;
-            changelogEntry = `${before.trim()}\n\n\n${changelogEntry}\n\n${after.trim()}`;
+        if (typeof s === 'string') {
+            return s;
         }
-        return changelogEntry;
-    }
-    async newChangelogEntry(changelogEntry, changelogPath, updatedManifest) {
-        var _a, _b, _c, _d;
-        let changelog;
-        try {
-            changelog = (await this.gh.getFileContents(changelogPath)).parsedContent;
+        else {
+            return s.version;
         }
-        catch (e) {
-            if (e.status !== 404) {
-                this.log(`Failed to retrieve ${changelogPath}: ${e}`, checkpoint_1.CheckpointType.Failure);
-                return '';
-            }
-            else {
-                this.log(`Creating a new changelog at ${changelogPath}`, checkpoint_1.CheckpointType.Success);
+    };
+    const getDepMap = (cargoDeps) => {
+        const result = {};
+        for (const [key, val] of Object.entries(cargoDeps)) {
+            const ver = depVer(val);
+            if (ver) {
+                result[key] = ver;
             }
         }
-        const changelogUpdater = new changelog_1.Changelog({
-            path: changelogPath,
-            changelogEntry,
-            version: (_b = (_a = updatedManifest.package) === null || _a === void 0 ? void 0 : _a.version) !== null && _b !== void 0 ? _b : '?',
-            packageName: (_d = (_c = updatedManifest.package) === null || _c === void 0 ? void 0 : _c.name) !== null && _d !== void 0 ? _d : '?',
-        });
-        return changelogUpdater.updateContent(changelog);
-    }
-    async getAllCrateInfos(members, pkgsWithPRData) {
-        var _a, _b, _c, _d;
-        const manifests = [];
-        for (const pkgPath of members) {
-            const manifestPath = `${pkgPath}/Cargo.toml`;
-            const manifestPkg = pkgsWithPRData.find(pkg => pkg.config.path === pkgPath);
-            // original contents of the manifest for the target package
-            const manifestContent = (_b = (_a = manifestPkg === null || manifestPkg === void 0 ? void 0 : manifestPkg.prData.changes.get(manifestPath)) === null || _a === void 0 ? void 0 : _a.content) !== null && _b !== void 0 ? _b : (await this.gh.getFileContents(manifestPath)).parsedContent;
-            const manifest = await common_1.parseCargoManifest(manifestContent);
-            const pkgName = (_c = manifest.package) === null || _c === void 0 ? void 0 : _c.name;
-            if (!pkgName) {
-                throw new Error(`package manifest at ${manifestPath} is missing [package.name]`);
-            }
-            const version = (_d = manifest.package) === null || _d === void 0 ? void 0 : _d.version;
-            if (!version) {
-                throw new Error(`package manifest at ${manifestPath} is missing [package.version]`);
+        return result;
+    };
+    const updates = new Map();
+    for (const depType of depTypes) {
+        const depUpdates = [];
+        const pkgDepTypes = updatedManifest[depType];
+        if (pkgDepTypes === undefined) {
+            continue;
+        }
+        for (const [depName, currentDepVer] of Object.entries(getDepMap(pkgDepTypes))) {
+            const origDepVer = depVer((_a = originalManifest[depType]) === null || _a === void 0 ? void 0 : _a[depName]);
+            if (currentDepVer !== origDepVer) {
+                depUpdates.push(`\n    * ${depName} bumped from ${origDepVer} to ${currentDepVer}`);
             }
-            manifests.push({
-                path: pkgPath,
-                name: pkgName,
-                version,
-                manifest,
-                manifestContent,
-                manifestPath,
-                manifestPkg,
-            });
         }
-        return manifests;
+        if (depUpdates.length > 0) {
+            updates.set(depType, depUpdates);
+        }
     }
-}
-exports.default = CargoWorkspaceDependencyUpdates;
-function buildCrateGraph(crateInfoMap) {
-    var _a, _b, _c;
-    const graph = new Map();
-    for (const crate of crateInfoMap.values()) {
-        const allDeps = Object.keys({
-            ...((_a = crate.manifest.dependencies) !== null && _a !== void 0 ? _a : {}),
-            ...((_b = crate.manifest['dev-dependencies']) !== null && _b !== void 0 ? _b : {}),
-            ...((_c = crate.manifest['build-dependencies']) !== null && _c !== void 0 ? _c : {}),
-        });
-        console.log({ allDeps });
-        const workspaceDeps = allDeps.filter(dep => crateInfoMap.has(dep));
-        graph.set(crate.name, {
-            name: crate.name,
-            deps: workspaceDeps,
-        });
+    for (const [dt, notes] of updates) {
+        depUpdateNotes += `\n  * ${dt}`;
+        for (const note of notes) {
+            depUpdateNotes += note;
+        }
     }
-    return graph;
-}
-/**
- * Given a list of graph nodes that form a DAG, returns the node names in
- * post-order (reverse depth-first), suitable for dependency updates and bumping.
- */
-function postOrder(graph) {
-    const result = [];
-    const resultSet = new Set();
-    // we're iterating the `Map` in insertion order (as per ECMA262), but
-    // that does not reflect any particular traversal of the graph, so we
-    // visit all nodes, opportunistically short-circuiting leafs when we've
-    // already visited them.
-    for (const node of graph.values()) {
-        visitPostOrder(graph, node, result, resultSet, []);
+    if (depUpdateNotes) {
+        return `* The following workspace dependencies were updated${depUpdateNotes}`;
     }
-    return result;
+    return '';
 }
-exports.postOrder = postOrder;
-function visitPostOrder(graph, node, result, resultSet, path) {
-    if (resultSet.has(node.name)) {
-        return;
-    }
-    if (path.indexOf(node.name) !== -1) {
-        throw new Error(`found cycle in dependency graph: ${path.join(' -> ')} -> ${node.name}`);
+const DEPENDENCY_HEADER = new RegExp('### Dependencies');
+function appendDependenciesSectionToChangelog(changelog, notes) {
+    if (!changelog) {
+        return `### Dependencies\n\n${notes}`;
     }
-    {
-        const nextPath = [...path, node.name];
-        for (const depName of node.deps) {
-            const dep = graph.get(depName);
-            if (!dep) {
-                throw new Error(`dependency not found in graph: ${depName}`);
+    const newLines = [];
+    let seenDependenciesSection = false;
+    let seenDependencySectionSpacer = false;
+    let injected = false;
+    for (const line of changelog.split('\n')) {
+        if (seenDependenciesSection) {
+            const trimmedLine = line.trim();
+            if (seenDependencySectionSpacer &&
+                !injected &&
+                !trimmedLine.startsWith('*')) {
+                newLines.push(changelog);
+                injected = true;
+            }
+            if (trimmedLine === '') {
+                seenDependencySectionSpacer = true;
             }
-            visitPostOrder(graph, dep, result, resultSet, nextPath);
         }
+        if (line.match(DEPENDENCY_HEADER)) {
+            seenDependenciesSection = true;
+        }
+        newLines.push(line);
+    }
+    if (injected) {
+        return newLines.join('\n');
     }
-    if (!resultSet.has(node.name)) {
-        resultSet.add(node.name);
-        result.push(node.name);
+    if (seenDependenciesSection) {
+        return `${changelog}\n${notes}`;
     }
+    return `${changelog}\n\n\n### Dependencies\n\n${notes}`;
+}
+function addPath(path, file) {
+    return path === manifest_1.ROOT_PROJECT_PATH ? file : `${path}/${file}`;
 }
 //# sourceMappingURL=cargo-workspace.js.map

package/build/src/plugins/merge.d.ts

@@ -0,0 +1,11 @@
+import { ManifestPlugin } from '../plugin';
+import { CandidateReleasePullRequest } from '../manifest';
+/**
+ * This plugin merges multiple pull requests into a single
+ * release pull request.
+ *
+ * Release notes are broken up using `<summary>`/`<details>` blocks.
+ */
+export declare class Merge extends ManifestPlugin {
+    run(candidates: CandidateReleasePullRequest[]): Promise<CandidateReleasePullRequest[]>;
+}