release-please 12.3.0 → 12.6.1

package/build/src/strategies/php-yoshi.js

@@ -0,0 +1,214 @@
+"use strict";
+// Copyright 2021 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PHPYoshi = void 0;
+const strategy_1 = require("../strategy");
+const changelog_1 = require("../updaters/changelog");
+const root_composer_update_packages_1 = require("../updaters/php/root-composer-update-packages");
+const php_manifest_1 = require("../updaters/php/php-manifest");
+const php_client_version_1 = require("../updaters/php/php-client-version");
+const version_1 = require("../version");
+const commit_1 = require("../commit");
+const commit_split_1 = require("../util/commit-split");
+const default_1 = require("../updaters/default");
+const logger_1 = require("../util/logger");
+const tag_name_1 = require("../util/tag-name");
+const pull_request_title_1 = require("../util/pull-request-title");
+const branch_name_1 = require("../util/branch-name");
+const pull_request_body_1 = require("../util/pull-request-body");
+const CHANGELOG_SECTIONS = [
+    { type: 'feat', section: 'Features' },
+    { type: 'fix', section: 'Bug Fixes' },
+    { type: 'perf', section: 'Performance Improvements' },
+    { type: 'revert', section: 'Reverts' },
+    { type: 'docs', section: 'Documentation' },
+    { type: 'chore', section: 'Miscellaneous Chores' },
+    { type: 'style', section: 'Styles', hidden: true },
+    { type: 'refactor', section: 'Code Refactoring', hidden: true },
+    { type: 'test', section: 'Tests', hidden: true },
+    { type: 'build', section: 'Build System', hidden: true },
+    { type: 'ci', section: 'Continuous Integration', hidden: true },
+];
+class PHPYoshi extends strategy_1.Strategy {
+    constructor(options) {
+        super({
+            ...options,
+            changelogSections: CHANGELOG_SECTIONS,
+        });
+    }
+    async buildReleasePullRequest(commits, latestRelease, draft, labels = []) {
+        var _a, _b, _c;
+        const conventionalCommits = this.postProcessCommits(commit_1.parseConventionalCommits(commits));
+        const newVersion = latestRelease
+            ? await this.versioningStrategy.bump(latestRelease.tag.version, conventionalCommits)
+            : this.initialReleaseVersion();
+        const cs = new commit_split_1.CommitSplit();
+        const splitCommits = cs.split(conventionalCommits);
+        const topLevelDirectories = Object.keys(splitCommits).sort();
+        const versionsMap = new Map();
+        const directoryVersionContents = {};
+        const component = await this.getComponent();
+        const newVersionTag = new tag_name_1.TagName(newVersion, component);
+        let releaseNotesBody = `## ${newVersion.toString()}`;
+        for (const directory of topLevelDirectories) {
+            try {
+                const contents = await this.github.getFileContentsOnBranch(this.addPath(`${directory}/VERSION`), this.targetBranch);
+                const version = version_1.Version.parse(contents.parsedContent);
+                const composer = await this.github.getFileJson(this.addPath(`${directory}/composer.json`), this.targetBranch);
+                directoryVersionContents[directory] = {
+                    versionContents: contents,
+                    composer,
+                };
+                const newVersion = await this.versioningStrategy.bump(version, splitCommits[directory]);
+                versionsMap.set(composer.name, newVersion);
+                const partialReleaseNotes = await this.changelogNotes.buildNotes(splitCommits[directory], {
+                    owner: this.repository.owner,
+                    repository: this.repository.repo,
+                    version: newVersion.toString(),
+                    previousTag: (_a = latestRelease === null || latestRelease === void 0 ? void 0 : latestRelease.tag) === null || _a === void 0 ? void 0 : _a.toString(),
+                    currentTag: newVersionTag.toString(),
+                    targetBranch: this.targetBranch,
+                });
+                releaseNotesBody = updatePHPChangelogEntry(`${composer.name} ${newVersion.toString()}`, releaseNotesBody, partialReleaseNotes);
+            }
+            catch (err) {
+                if (err.status === 404) {
+                    // if the updated path has no VERSION, assume this isn't a
+                    // module that needs updating.
+                    continue;
+                }
+                else {
+                    throw err;
+                }
+            }
+        }
+        const pullRequestTitle = pull_request_title_1.PullRequestTitle.ofComponentTargetBranchVersion(component || '', this.targetBranch, newVersion);
+        const branchName = component
+            ? branch_name_1.BranchName.ofComponentTargetBranch(component, this.targetBranch)
+            : branch_name_1.BranchName.ofTargetBranch(this.targetBranch);
+        const updates = await this.buildUpdates({
+            changelogEntry: releaseNotesBody,
+            newVersion,
+            versionsMap,
+            latestVersion: latestRelease === null || latestRelease === void 0 ? void 0 : latestRelease.tag.version,
+        });
+        for (const directory in directoryVersionContents) {
+            const componentInfo = directoryVersionContents[directory];
+            const version = versionsMap.get(componentInfo.composer.name);
+            if (!version) {
+                logger_1.logger.warn(`No version found for ${componentInfo.composer.name}`);
+                continue;
+            }
+            updates.push({
+                path: this.addPath(`${directory}/VERSION`),
+                createIfMissing: false,
+                cachedFileContents: componentInfo.versionContents,
+                updater: new default_1.DefaultUpdater({
+                    version,
+                }),
+            });
+            if ((_c = (_b = componentInfo.composer.extra) === null || _b === void 0 ? void 0 : _b.component) === null || _c === void 0 ? void 0 : _c.entry) {
+                updates.push({
+                    path: this.addPath(`${directory}/${componentInfo.composer.extra.component.entry}`),
+                    createIfMissing: false,
+                    updater: new php_client_version_1.PHPClientVersion({
+                        version,
+                    }),
+                });
+            }
+        }
+        const pullRequestBody = new pull_request_body_1.PullRequestBody([
+            {
+                component,
+                version: newVersion,
+                notes: releaseNotesBody,
+            },
+        ]);
+        return {
+            title: pullRequestTitle,
+            body: pullRequestBody,
+            updates,
+            labels,
+            headRefName: branchName.toString(),
+            version: newVersion,
+            draft: draft !== null && draft !== void 0 ? draft : false,
+        };
+    }
+    async buildUpdates(options) {
+        const updates = [];
+        const version = options.newVersion;
+        const versionsMap = options.versionsMap;
+        updates.push({
+            path: this.addPath(this.changelogPath),
+            createIfMissing: true,
+            updater: new changelog_1.Changelog({
+                version,
+                changelogEntry: options.changelogEntry,
+            }),
+        });
+        // update the aggregate package information in the root
+        // composer.json and manifest.json.
+        updates.push({
+            path: this.addPath('composer.json'),
+            createIfMissing: false,
+            updater: new root_composer_update_packages_1.RootComposerUpdatePackages({
+                version,
+                versionsMap,
+            }),
+        });
+        updates.push({
+            path: this.addPath('docs/manifest.json'),
+            createIfMissing: false,
+            updater: new php_manifest_1.PHPManifest({
+                version,
+                versionsMap,
+            }),
+        });
+        updates.push({
+            path: this.addPath('src/Version.php'),
+            createIfMissing: false,
+            updater: new php_client_version_1.PHPClientVersion({
+                version,
+                versionsMap,
+            }),
+        });
+        updates.push({
+            path: this.addPath('src/ServiceBuilder.php'),
+            createIfMissing: false,
+            updater: new php_client_version_1.PHPClientVersion({
+                version,
+                versionsMap,
+            }),
+        });
+        return updates;
+    }
+}
+exports.PHPYoshi = PHPYoshi;
+function updatePHPChangelogEntry(pkgKey, changelogEntry, entryUpdate) {
+    // Remove the first line of the entry, in favor of <summary>.
+    // This also allows us to use the same regex for extracting release
+    // notes (since the string "## v0.0.0" doesn't show up multiple times).
+    const entryUpdateSplit = entryUpdate.split(/\r?\n/);
+    entryUpdateSplit.shift();
+    entryUpdate = entryUpdateSplit.join('\n');
+    return `${changelogEntry}
+
+<details><summary>${pkgKey}</summary>
+
+${entryUpdate}
+
+</details>`;
+}
+//# sourceMappingURL=php-yoshi.js.map

package/build/src/strategies/php.d.ts

@@ -0,0 +1,6 @@
+import { Strategy, BuildUpdatesOptions, StrategyOptions } from '../strategy';
+import { Update } from '../update';
+export declare class PHP extends Strategy {
+    constructor(options: StrategyOptions);
+    protected buildUpdates(options: BuildUpdatesOptions): Promise<Update[]>;
+}

package/build/src/strategies/php.js

@@ -0,0 +1,67 @@
+"use strict";
+// Copyright 2021 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PHP = void 0;
+// Generic
+const changelog_1 = require("../updaters/changelog");
+// PHP Specific.
+const root_composer_update_packages_1 = require("../updaters/php/root-composer-update-packages");
+const strategy_1 = require("../strategy");
+const CHANGELOG_SECTIONS = [
+    { type: 'feat', section: 'Features' },
+    { type: 'fix', section: 'Bug Fixes' },
+    { type: 'perf', section: 'Performance Improvements' },
+    { type: 'revert', section: 'Reverts' },
+    { type: 'chore', section: 'Miscellaneous Chores' },
+    { type: 'docs', section: 'Documentation', hidden: true },
+    { type: 'style', section: 'Styles', hidden: true },
+    { type: 'refactor', section: 'Code Refactoring', hidden: true },
+    { type: 'test', section: 'Tests', hidden: true },
+    { type: 'build', section: 'Build System', hidden: true },
+    { type: 'ci', section: 'Continuous Integration', hidden: true },
+];
+class PHP extends strategy_1.Strategy {
+    constructor(options) {
+        var _a;
+        options.changelogSections = (_a = options.changelogSections) !== null && _a !== void 0 ? _a : CHANGELOG_SECTIONS;
+        super(options);
+    }
+    async buildUpdates(options) {
+        const updates = [];
+        const version = options.newVersion;
+        const versionsMap = new Map();
+        versionsMap.set('version', version);
+        updates.push({
+            path: this.addPath(this.changelogPath),
+            createIfMissing: true,
+            updater: new changelog_1.Changelog({
+                version,
+                changelogEntry: options.changelogEntry,
+            }),
+        });
+        // update composer.json
+        updates.push({
+            path: this.addPath('composer.json'),
+            createIfMissing: false,
+            updater: new root_composer_update_packages_1.RootComposerUpdatePackages({
+                version,
+                versionsMap,
+            }),
+        });
+        return updates;
+    }
+}
+exports.PHP = PHP;
+//# sourceMappingURL=php.js.map

package/build/src/strategies/python.d.ts

@@ -0,0 +1,8 @@
+import { Strategy, BuildUpdatesOptions } from '../strategy';
+import { Update } from '../update';
+import { Version } from '../version';
+export declare class Python extends Strategy {
+    protected buildUpdates(options: BuildUpdatesOptions): Promise<Update[]>;
+    private getPyProject;
+    protected initialReleaseVersion(): Version;
+}

package/build/src/strategies/python.js

@@ -0,0 +1,117 @@
+"use strict";
+// Copyright 2019 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Python = void 0;
+const strategy_1 = require("../strategy");
+const changelog_1 = require("../updaters/changelog");
+const version_1 = require("../version");
+const setup_cfg_1 = require("../updaters/python/setup-cfg");
+const setup_py_1 = require("../updaters/python/setup-py");
+const pyproject_toml_1 = require("../updaters/python/pyproject-toml");
+const logger_1 = require("../util/logger");
+const python_file_with_version_1 = require("../updaters/python/python-file-with-version");
+class Python extends strategy_1.Strategy {
+    async buildUpdates(options) {
+        var _a;
+        const updates = [];
+        const version = options.newVersion;
+        updates.push({
+            path: this.addPath(this.changelogPath),
+            createIfMissing: true,
+            updater: new changelog_1.Changelog({
+                version,
+                changelogEntry: options.changelogEntry,
+            }),
+        });
+        updates.push({
+            path: this.addPath('setup.cfg'),
+            createIfMissing: false,
+            updater: new setup_cfg_1.SetupCfg({
+                version,
+            }),
+        });
+        updates.push({
+            path: this.addPath('setup.py'),
+            createIfMissing: false,
+            updater: new setup_py_1.SetupPy({
+                version,
+            }),
+        });
+        const parsedPyProject = await this.getPyProject(this.addPath('pyproject.toml'));
+        const pyProject = (parsedPyProject === null || parsedPyProject === void 0 ? void 0 : parsedPyProject.project) || ((_a = parsedPyProject === null || parsedPyProject === void 0 ? void 0 : parsedPyProject.tool) === null || _a === void 0 ? void 0 : _a.poetry);
+        let projectName = this.component;
+        if (pyProject) {
+            updates.push({
+                path: this.addPath('pyproject.toml'),
+                createIfMissing: false,
+                updater: new pyproject_toml_1.PyProjectToml({
+                    version,
+                }),
+            });
+            projectName = pyProject.name;
+        }
+        else {
+            logger_1.logger.warn(parsedPyProject
+                ? 'invalid pyproject.toml'
+                : `file ${this.addPath('pyproject.toml')} did not exist`);
+        }
+        if (!projectName) {
+            logger_1.logger.warn('No project/component found.');
+        }
+        else {
+            updates.push({
+                path: this.addPath(`${projectName}/__init__.py`),
+                createIfMissing: false,
+                updater: new python_file_with_version_1.PythonFileWithVersion({
+                    version,
+                }),
+            });
+            updates.push({
+                path: this.addPath(`src/${projectName}/__init__.py`),
+                createIfMissing: false,
+                updater: new python_file_with_version_1.PythonFileWithVersion({
+                    version,
+                }),
+            });
+        }
+        // There should be only one version.py, but foreach in case that is incorrect
+        const versionPyFilesSearch = this.github.findFilesByFilename('version.py', this.path);
+        const versionPyFiles = await versionPyFilesSearch;
+        versionPyFiles.forEach(path => {
+            updates.push({
+                path: this.addPath(path),
+                createIfMissing: false,
+                updater: new python_file_with_version_1.PythonFileWithVersion({
+                    version,
+                }),
+            });
+        });
+        return updates;
+    }
+    async getPyProject(path) {
+        try {
+            const content = await this.github.getFileContentsOnBranch(path, this.targetBranch);
+            return pyproject_toml_1.parsePyProject(content.parsedContent);
+        }
+        catch (e) {
+            return null;
+        }
+    }
+    initialReleaseVersion() {
+        return version_1.Version.parse('0.1.0');
+    }
+}
+exports.Python = Python;
+//# sourceMappingURL=python.js.map

package/build/src/strategies/ruby-yoshi.d.ts

@@ -0,0 +1,17 @@
+import { StrategyOptions, Strategy, BuildUpdatesOptions } from '../strategy';
+import { ConventionalCommit } from '../commit';
+import { Update } from '../update';
+import { Release } from '../release';
+import { Version } from '../version';
+import { TagName } from '../util/tag-name';
+interface RubyYoshiStrategyOptions extends StrategyOptions {
+    versionFile?: string;
+}
+export declare class RubyYoshi extends Strategy {
+    readonly versionFile: string;
+    constructor(options: RubyYoshiStrategyOptions);
+    protected buildUpdates(options: BuildUpdatesOptions): Promise<Update[]>;
+    protected postProcessCommits(commits: ConventionalCommit[]): ConventionalCommit[];
+    protected buildReleaseNotes(conventionalCommits: ConventionalCommit[], newVersion: Version, newVersionTag: TagName, latestRelease?: Release): Promise<string>;
+}
+export {};

package/build/src/strategies/ruby-yoshi.js

@@ -0,0 +1,116 @@
+"use strict";
+// Copyright 2019 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RubyYoshi = void 0;
+const indent_commit_1 = require("../util/indent-commit");
+// Generic
+const changelog_1 = require("../updaters/changelog");
+// RubyYoshi
+const version_rb_1 = require("../updaters/ruby/version-rb");
+const strategy_1 = require("../strategy");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const manifest_1 = require("../manifest");
+const CHANGELOG_SECTIONS = [
+    { type: 'feat', section: 'Features' },
+    { type: 'fix', section: 'Bug Fixes' },
+    { type: 'perf', section: 'Performance Improvements' },
+    { type: 'revert', section: 'Reverts' },
+    { type: 'docs', section: 'Documentation' },
+    { type: 'style', section: 'Styles', hidden: true },
+    { type: 'chore', section: 'Miscellaneous Chores', hidden: true },
+    { type: 'refactor', section: 'Code Refactoring', hidden: true },
+    { type: 'test', section: 'Tests', hidden: true },
+    { type: 'build', section: 'Build System', hidden: true },
+    { type: 'ci', section: 'Continuous Integration', hidden: true },
+];
+class RubyYoshi extends strategy_1.Strategy {
+    constructor(options) {
+        var _a;
+        super({
+            ...options,
+            changelogSections: CHANGELOG_SECTIONS,
+            commitPartial: fs_1.readFileSync(path_1.resolve(__dirname, '../../../templates/commit.hbs'), 'utf8'),
+            headerPartial: fs_1.readFileSync(path_1.resolve(__dirname, '../../../templates/header.hbs'), 'utf8'),
+            mainTemplate: fs_1.readFileSync(path_1.resolve(__dirname, '../../../templates/template.hbs'), 'utf8'),
+            tagSeparator: '/',
+        });
+        this.versionFile = (_a = options.versionFile) !== null && _a !== void 0 ? _a : '';
+    }
+    async buildUpdates(options) {
+        const updates = [];
+        const version = options.newVersion;
+        updates.push({
+            path: this.addPath(this.changelogPath),
+            createIfMissing: true,
+            updater: new changelog_1.Changelog({
+                version,
+                changelogEntry: options.changelogEntry,
+            }),
+        });
+        const versionFile = this.versionFile
+            ? this.versionFile
+            : `lib/${(this.component || '').replace(/-/g, '/')}/version.rb`;
+        updates.push({
+            path: this.addPath(versionFile),
+            createIfMissing: false,
+            updater: new version_rb_1.VersionRB({
+                version,
+            }),
+        });
+        return updates;
+    }
+    postProcessCommits(commits) {
+        commits.forEach(commit => {
+            commit.message = indent_commit_1.indentCommit(commit);
+        });
+        return commits;
+    }
+    async buildReleaseNotes(conventionalCommits, newVersion, newVersionTag, latestRelease) {
+        const releaseNotes = await super.buildReleaseNotes(conventionalCommits, newVersion, newVersionTag, latestRelease);
+        if (!latestRelease) {
+            return releaseNotes;
+        }
+        // summarize the commits that landed:
+        let summary = '### Commits since last release:\n\n';
+        const updatedFiles = {};
+        const repoUrl = `${this.repository.owner}/${this.repository.repo}`;
+        for (const commit of conventionalCommits) {
+            if (!commit.sha)
+                continue;
+            const splitMessage = commit.message.split('\n');
+            summary += `* [${splitMessage[0]}](https://github.com/${repoUrl}/commit/${commit.sha})\n`;
+            if (splitMessage.length > 2) {
+                summary = `${summary}<pre><code>${splitMessage
+                    .slice(1)
+                    .join('\n')}</code></pre>\n`;
+            }
+            commit.files.forEach(file => {
+                if (this.path === manifest_1.ROOT_PROJECT_PATH || file.startsWith(this.path)) {
+                    updatedFiles[file] = true;
+                }
+            });
+        }
+        // summarize the files that changed:
+        summary = `${summary}\n### Files edited since last release:\n\n<pre><code>`;
+        Object.keys(updatedFiles).forEach(file => {
+            summary += `${file}\n`;
+        });
+        summary += `</code></pre>\n[Compare Changes](https://github.com/${repoUrl}/compare/${latestRelease.sha}...HEAD)\n`;
+        return releaseNotes + `\n---\n${summary}`;
+    }
+}
+exports.RubyYoshi = RubyYoshi;
+//# sourceMappingURL=ruby-yoshi.js.map

package/build/src/strategies/ruby.d.ts

@@ -0,0 +1,13 @@
+import { StrategyOptions, Strategy, BuildUpdatesOptions } from '../strategy';
+import { ConventionalCommit } from '../commit';
+import { Update } from '../update';
+interface RubyStrategyOptions extends StrategyOptions {
+    versionFile?: string;
+}
+export declare class Ruby extends Strategy {
+    readonly versionFile: string;
+    constructor(options: RubyStrategyOptions);
+    protected buildUpdates(options: BuildUpdatesOptions): Promise<Update[]>;
+    protected postProcessCommits(commits: ConventionalCommit[]): ConventionalCommit[];
+}
+export {};

package/build/src/strategies/ruby.js

@@ -0,0 +1,61 @@
+"use strict";
+// Copyright 2019 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Ruby = void 0;
+const indent_commit_1 = require("../util/indent-commit");
+// Generic
+const changelog_1 = require("../updaters/changelog");
+// Ruby
+const version_rb_1 = require("../updaters/ruby/version-rb");
+const strategy_1 = require("../strategy");
+class Ruby extends strategy_1.Strategy {
+    constructor(options) {
+        var _a;
+        super(options);
+        this.versionFile = (_a = options.versionFile) !== null && _a !== void 0 ? _a : '';
+        this.tagSeparator = '/';
+    }
+    async buildUpdates(options) {
+        const updates = [];
+        const version = options.newVersion;
+        updates.push({
+            path: this.addPath(this.changelogPath),
+            createIfMissing: true,
+            updater: new changelog_1.Changelog({
+                version,
+                changelogEntry: options.changelogEntry,
+            }),
+        });
+        const versionFile = this.versionFile
+            ? this.versionFile
+            : `lib/${(this.component || '').replace(/-/g, '/')}/version.rb`;
+        updates.push({
+            path: this.addPath(versionFile),
+            createIfMissing: false,
+            updater: new version_rb_1.VersionRB({
+                version,
+            }),
+        });
+        return updates;
+    }
+    postProcessCommits(commits) {
+        commits.forEach(commit => {
+            commit.message = indent_commit_1.indentCommit(commit);
+        });
+        return commits;
+    }
+}
+exports.Ruby = Ruby;
+//# sourceMappingURL=ruby.js.map

package/build/src/strategies/rust.d.ts

@@ -0,0 +1,20 @@
+import { CargoManifest } from '../updaters/rust/common';
+import { Strategy, BuildUpdatesOptions } from '../strategy';
+import { Version } from '../version';
+import { Update } from '../update';
+export declare class Rust extends Strategy {
+    private packageManifest?;
+    private workspaceManifest?;
+    protected buildUpdates(options: BuildUpdatesOptions): Promise<Update[]>;
+    protected initialReleaseVersion(): Version;
+    getDefaultPackageName(): Promise<string | undefined>;
+    /**
+     * @returns the package's manifest, ie. `crates/foobar/Cargo.toml`
+     */
+    protected getPackageManifest(): Promise<CargoManifest | null>;
+    /**
+     * @returns the workspace's manifest, ie. `Cargo.toml` (top-level)
+     */
+    protected getWorkspaceManifest(): Promise<CargoManifest | null>;
+    protected getManifest(path: string): Promise<CargoManifest | null>;
+}