release-please 13.0.0 → 13.1.1

package/CHANGELOG.md

@@ -4,6 +4,34 @@
 
 [1]: https://www.npmjs.com/package/release-please?activeTab=versions
 
+### [13.1.1](https://www.github.com/googleapis/release-please/compare/v13.1.0...v13.1.1) (2022-01-03)
+
+
+### Bug Fixes
+
+* **rust:** Rust strategy should update root Cargo files in a workspace ([#1182](https://www.github.com/googleapis/release-please/issues/1182)) ([26a040c](https://www.github.com/googleapis/release-please/commit/26a040cf06a7a2cf97b9ebc3d204bb36f0b2c13b)), closes [#1170](https://www.github.com/googleapis/release-please/issues/1170) [#1096](https://www.github.com/googleapis/release-please/issues/1096)
+
+## [13.1.0](https://www.github.com/googleapis/release-please/compare/v13.0.2...v13.1.0) (2021-12-29)
+
+
+### Features
+
+* introduce generic updater ([#1157](https://www.github.com/googleapis/release-please/issues/1157)) ([c97598c](https://www.github.com/googleapis/release-please/commit/c97598c137b5018c76f5d62137e277b991f4bfa3)), closes [#435](https://www.github.com/googleapis/release-please/issues/435) [#305](https://www.github.com/googleapis/release-please/issues/305) [#1139](https://www.github.com/googleapis/release-please/issues/1139) [#1174](https://www.github.com/googleapis/release-please/issues/1174)
+
+### [13.0.2](https://www.github.com/googleapis/release-please/compare/v13.0.1...v13.0.2) (2021-12-29)
+
+
+### Bug Fixes
+
+* set the title when creating a release ([#1177](https://www.github.com/googleapis/release-please/issues/1177)) ([d05001f](https://www.github.com/googleapis/release-please/commit/d05001faedcdf11869cd9db06e3a8a8071af4470))
+
+### [13.0.1](https://www.github.com/googleapis/release-please/compare/v13.0.0...v13.0.1) (2021-12-23)
+
+
+### Bug Fixes
+
+* export public interface types from index.ts ([#1169](https://www.github.com/googleapis/release-please/issues/1169)) ([cef6407](https://www.github.com/googleapis/release-please/commit/cef6407b05b8bbbc17d0c0b9d4704dc1de80ccf0))
+
 ## [13.0.0](https://www.github.com/googleapis/release-please/compare/v12.6.0...v13.0.0) (2021-12-22)
 
 

package/README.md

@@ -91,6 +91,24 @@ chore: release 2.0.0
 Release-As: 2.0.0
 ```
 
+## How can I fix release notes?
+
+If you have merged a pull request and you would like to amend the commit message
+used to generate the release notes for that commit, you can edit the body of
+the merged pull requests and add a section like:
+
+```
+BEGIN_COMMIT_OVERRIDE
+feat: add ability to override merged commit message
+
+fix: another message
+chore: a third message
+END_COMMIT_OVERRIDE
+```
+
+The next time release please runs, it will use that override section as the
+commit message instead of the merged commit message.
+
 ## Strategy (Language) types supported
 
 Release Please automates releases for the following flavors of repositories:

package/build/src/factory.js

@@ -68,6 +68,7 @@ const allReleaseTypes = [
 const releasers = {
     go: options => new go_1.Go(options),
     'go-yoshi': options => new go_yoshi_1.GoYoshi(options),
+    'java-yoshi': options => new java_yoshi_1.JavaYoshi(options),
     'krm-blueprint': options => new krm_blueprint_1.KRMBlueprint(options),
     node: options => new node_1.Node(options),
     ocaml: options => new ocaml_1.OCaml(options),
@@ -122,6 +123,7 @@ async function buildStrategy(options) {
         includeComponentInTag: options.includeComponentInTag,
         changelogNotes,
         pullRequestTitlePattern: options.pullRequestTitlePattern,
+        extraFiles: options.extraFiles,
     };
     switch (options.releaseType) {
         case 'ruby': {
@@ -136,23 +138,15 @@ async function buildStrategy(options) {
                 versionFile: options.versionFile,
             });
         }
-        case 'java-yoshi': {
-            return new java_yoshi_1.JavaYoshi({
-                ...strategyOptions,
-                extraFiles: options.extraFiles,
-            });
-        }
         case 'java-backport': {
             return new java_yoshi_1.JavaYoshi({
                 ...strategyOptions,
-                extraFiles: options.extraFiles,
                 versioningStrategy: new always_bump_patch_1.AlwaysBumpPatch(),
             });
         }
         case 'java-bom': {
             return new java_yoshi_1.JavaYoshi({
                 ...strategyOptions,
-                extraFiles: options.extraFiles,
                 versioningStrategy: new dependency_manifest_1.DependencyManifest({
                     bumpMinorPreMajor: options.bumpMinorPreMajor,
                     bumpPatchForMinorPreMajor: options.bumpPatchForMinorPreMajor,
@@ -162,7 +156,6 @@ async function buildStrategy(options) {
         case 'java-lts': {
             return new java_yoshi_1.JavaYoshi({
                 ...strategyOptions,
-                extraFiles: options.extraFiles,
                 versioningStrategy: new service_pack_1.ServicePackVersioningStrategy(),
             });
         }

package/build/src/github.js

@@ -299,6 +299,7 @@ class GitHub {
          */
         this.createRelease = wrapAsync(async (release, options = {}) => {
             const resp = await this.octokit.repos.createRelease({
+                name: release.name,
                 owner: this.repository.owner,
                 repo: this.repository.repo,
                 tag_name: release.tag.toString(),

package/build/src/index.d.ts

@@ -0,0 +1,5 @@
+export * as Errors from './errors';
+export { Manifest, ReleaserConfig, ManifestOptions } from './manifest';
+export { ReleaseType, getReleaserTypes, VersioningStrategyType, getVersioningStrategyTypes, ChangelogNotesType, getChangelogTypes, } from './factory';
+export { Logger, setLogger } from './util/logger';
+export { GitHub } from './github';

package/build/src/index.js

@@ -0,0 +1,27 @@
+"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.Errors = require("./errors");
+var manifest_1 = require("./manifest");
+Object.defineProperty(exports, "Manifest", { enumerable: true, get: function () { return manifest_1.Manifest; } });
+var factory_1 = require("./factory");
+Object.defineProperty(exports, "getReleaserTypes", { enumerable: true, get: function () { return factory_1.getReleaserTypes; } });
+Object.defineProperty(exports, "getVersioningStrategyTypes", { enumerable: true, get: function () { return factory_1.getVersioningStrategyTypes; } });
+Object.defineProperty(exports, "getChangelogTypes", { enumerable: true, get: function () { return factory_1.getChangelogTypes; } });
+var logger_1 = require("./util/logger");
+Object.defineProperty(exports, "setLogger", { enumerable: true, get: function () { return logger_1.setLogger; } });
+var github_1 = require("./github");
+Object.defineProperty(exports, "GitHub", { enumerable: true, get: function () { return github_1.GitHub; } });
+//# sourceMappingURL=index.js.map

package/build/src/manifest.js

@@ -182,6 +182,7 @@ class Manifest {
                 logger_1.logger.debug(`Found release for path ${path}, ${release.tagName}`);
                 releaseShasByPath[path] = release.sha;
                 releasesByPath[path] = {
+                    name: release.name,
                     tag: tagName,
                     sha: release.sha,
                     notes: release.notes || '',

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

@@ -26,6 +26,7 @@ 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");
 const versioning_strategy_1 = require("../versioning-strategy");
+const cargo_lock_1 = require("../updaters/rust/cargo-lock");
 /**
  * The plugin analyzed a cargo workspace and will bump dependencies
  * of managed packages if those dependencies are being updated.
@@ -50,7 +51,9 @@ class CargoWorkspace extends workspace_1.WorkspacePlugin {
         }
         const allCrates = [];
         const candidatesByPackage = {};
-        for (const path of cargoManifest.workspace.members) {
+        const members = cargoManifest.workspace.members;
+        members.push(manifest_1.ROOT_PROJECT_PATH);
+        for (const path of 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);
@@ -60,7 +63,8 @@ class CargoWorkspace extends workspace_1.WorkspacePlugin {
             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]`);
+                logger_1.logger.warn(`package manifest at ${manifestPath} is missing [package.name]`);
+                continue;
             }
             if (candidate) {
                 candidatesByPackage[packageName] = candidate;
@@ -105,9 +109,15 @@ class CargoWorkspace extends workspace_1.WorkspacePlugin {
                 if (update.path === addPath(existingCandidate.path, 'Cargo.toml')) {
                     update.updater = new raw_content_1.RawContent(updatedContent);
                 }
-                else if (update.updater instanceof changelog_1.Changelog) {
+                else if (update.updater instanceof changelog_1.Changelog && dependencyNotes) {
                     update.updater.changelogEntry = appendDependenciesSectionToChangelog(update.updater.changelogEntry, dependencyNotes);
                 }
+                else if (update.path === addPath(existingCandidate.path, 'Cargo.lock')) {
+                    update.updater = new cargo_lock_1.CargoLock({
+                        version,
+                        versionsMap: updatedVersions,
+                    });
+                }
                 return update;
             });
         // append dependency notes
@@ -195,8 +205,7 @@ class CargoWorkspace extends workspace_1.WorkspacePlugin {
         return graph;
     }
     inScope(candidate) {
-        return (candidate.config.releaseType === 'rust' &&
-            candidate.path !== manifest_1.ROOT_PROJECT_PATH);
+        return candidate.config.releaseType === 'rust';
     }
     packageNameFromPackage(pkg) {
         return pkg.name;

package/build/src/plugins/merge.js

@@ -31,36 +31,18 @@ class Merge extends plugin_1.ManifestPlugin {
         if (candidates.length < 1) {
             return candidates;
         }
-        const updatesByPath = {};
         const releaseData = [];
         const labels = new Set();
+        let rawUpdates = [];
         for (const candidate of candidates) {
             const pullRequest = candidate.pullRequest;
-            for (const update of pullRequest.updates) {
-                if (updatesByPath[update.path]) {
-                    updatesByPath[update.path].push(update);
-                }
-                else {
-                    updatesByPath[update.path] = [update];
-                }
-            }
+            rawUpdates = rawUpdates.concat(...pullRequest.updates);
             for (const label of pullRequest.labels) {
                 labels.add(label);
             }
             releaseData.push(...pullRequest.body.releaseData);
         }
-        const updates = [];
-        for (const path in updatesByPath) {
-            const update = updatesByPath[path];
-            const updaters = update.map(u => u.updater);
-            updates.push({
-                path,
-                createIfMissing: update[0].createIfMissing,
-                updater: updaters.length === 1
-                    ? updaters[0]
-                    : new composite_1.CompositeUpdater(...updaters),
-            });
-        }
+        const updates = composite_1.mergeUpdates(rawUpdates);
         const pullRequest = {
             title: pull_request_title_1.PullRequestTitle.ofTargetBranch(this.targetBranch, manifest_1.MANIFEST_PULL_REQUEST_TITLE_PATTERN),
             body: new pull_request_body_1.PullRequestBody(releaseData),

package/build/src/release.d.ts

@@ -1,5 +1,6 @@
 import { TagName } from './util/tag-name';
 export interface Release {
+    readonly name?: string;
     readonly tag: TagName;
     readonly sha: string;
     readonly notes: string;

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

@@ -36,6 +36,7 @@ export interface BaseStrategyOptions {
     changelogNotes?: ChangelogNotes;
     includeComponentInTag?: boolean;
     pullRequestTitlePattern?: string;
+    extraFiles?: string[];
 }
 /**
  * A strategy is responsible for determining which files are
@@ -55,6 +56,7 @@ export declare abstract class BaseStrategy implements Strategy {
     private releaseAs?;
     private includeComponentInTag;
     private pullRequestTitlePattern?;
+    readonly extraFiles: string[];
     readonly changelogNotes: ChangelogNotes;
     protected changelogSections?: ChangelogSection[];
     constructor(options: BaseStrategyOptions);
@@ -90,6 +92,7 @@ export declare abstract class BaseStrategy implements Strategy {
      *   open a pull request.
      */
     buildReleasePullRequest(commits: Commit[], latestRelease?: Release, draft?: boolean, labels?: string[]): Promise<ReleasePullRequest | undefined>;
+    private extraFileUpdates;
     protected changelogEmpty(changelogEntry: string): boolean;
     protected updateVersionsMap(versionsMap: VersionsMap, conventionalCommits: ConventionalCommit[]): Promise<VersionsMap>;
     protected buildNewVersion(conventionalCommits: ConventionalCommit[], latestRelease?: Release): Promise<Version>;

package/build/src/strategies/base.js

@@ -24,6 +24,8 @@ const logger_1 = require("../util/logger");
 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 composite_1 = require("../updaters/composite");
+const generic_1 = require("../updaters/generic");
 const DEFAULT_CHANGELOG_PATH = 'CHANGELOG.md';
 /**
  * A strategy is responsible for determining which files are
@@ -50,6 +52,7 @@ class BaseStrategy {
             options.changelogNotes || new default_2.DefaultChangelogNotes(options);
         this.includeComponentInTag = (_a = options.includeComponentInTag) !== null && _a !== void 0 ? _a : true;
         this.pullRequestTitlePattern = options.pullRequestTitlePattern;
+        this.extraFiles = options.extraFiles || [];
     }
     /**
      * Return the component for this strategy. This may be a computed field.
@@ -127,6 +130,7 @@ class BaseStrategy {
             versionsMap,
             latestVersion: latestRelease === null || latestRelease === void 0 ? void 0 : latestRelease.tag.version,
         });
+        const updatesWithExtras = composite_1.mergeUpdates(updates.concat(...this.extraFileUpdates(newVersion)));
         const pullRequestBody = new pull_request_body_1.PullRequestBody([
             {
                 component,
@@ -137,13 +141,23 @@ class BaseStrategy {
         return {
             title: pullRequestTitle,
             body: pullRequestBody,
-            updates,
+            updates: updatesWithExtras,
             labels,
             headRefName: branchName.toString(),
             version: newVersion,
             draft: draft !== null && draft !== void 0 ? draft : false,
         };
     }
+    extraFileUpdates(version) {
+        const genericUpdater = new generic_1.Generic({ version });
+        return this.extraFiles.map(path => {
+            return {
+                path,
+                createIfMissing: false,
+                updater: genericUpdater,
+            };
+        });
+    }
     changelogEmpty(changelogEntry) {
         return changelogEntry.split('\n').length <= 1;
     }
@@ -223,7 +237,11 @@ class BaseStrategy {
             return;
         }
         const tag = new tag_name_1.TagName(version, this.includeComponentInTag ? component : undefined, this.tagSeparator);
+        const releaseName = component && this.includeComponentInTag
+            ? `${component}: v${version.toString()}`
+            : `v${version.toString()}`;
         return {
+            name: releaseName,
             tag,
             notes: notes || '',
             sha: mergedPullRequest.sha,

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

@@ -5,14 +5,10 @@ import { GitHubFileContents } from '../github';
 import { Commit, ConventionalCommit } from '../commit';
 import { Release } from '../release';
 import { ReleasePullRequest } from '../release-pull-request';
-interface JavaStrategyOptions extends BaseStrategyOptions {
-    extraFiles?: string[];
-}
 export declare class JavaYoshi extends BaseStrategy {
-    readonly extraFiles: string[];
     private versionsContent?;
     private snapshotVersioning;
-    constructor(options: JavaStrategyOptions);
+    constructor(options: BaseStrategyOptions);
     buildReleasePullRequest(commits: Commit[], latestRelease?: Release, draft?: boolean, labels?: string[]): Promise<ReleasePullRequest | undefined>;
     private buildSnapshotPullRequest;
     private needsSnapshot;
@@ -22,4 +18,3 @@ export declare class JavaYoshi extends BaseStrategy {
     protected updateVersionsMap(versionsMap: VersionsMap, conventionalCommits: ConventionalCommit[]): Promise<VersionsMap>;
     protected initialReleaseVersion(): Version;
 }
-export {};

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

@@ -49,7 +49,6 @@ class JavaYoshi extends base_1.BaseStrategy {
         const parentVersioningStrategy = options.versioningStrategy || new default_1.DefaultVersioningStrategy();
         options.versioningStrategy = new java_snapshot_1.JavaSnapshot(parentVersioningStrategy);
         super(options);
-        this.extraFiles = options.extraFiles || [];
         this.snapshotVersioning = new java_add_snapshot_1.JavaAddSnapshot(parentVersioningStrategy);
     }
     async buildReleasePullRequest(commits, latestRelease, draft, labels = []) {

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

@@ -12,9 +12,6 @@ export declare class Rust extends BaseStrategy {
      * @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>;
+    private getContent;
     protected getManifest(path: string): Promise<CargoManifest | null>;
 }

package/build/src/strategies/rust.js

@@ -25,6 +25,7 @@ const base_1 = require("./base");
 const version_1 = require("../version");
 class Rust extends base_1.BaseStrategy {
     async buildUpdates(options) {
+        var _a, _b, _c;
         const updates = [];
         const version = options.newVersion;
         updates.push({
@@ -35,30 +36,62 @@ class Rust extends base_1.BaseStrategy {
                 changelogEntry: options.changelogEntry,
             }),
         });
-        const workspaceManifest = await this.getWorkspaceManifest();
-        const manifestPaths = [];
-        let lockPath;
-        if (workspaceManifest &&
-            workspaceManifest.workspace &&
-            workspaceManifest.workspace.members) {
+        const workspaceManifest = await this.getPackageManifest();
+        const versionsMap = new Map();
+        if ((_a = workspaceManifest === null || workspaceManifest === void 0 ? void 0 : workspaceManifest.workspace) === null || _a === void 0 ? void 0 : _a.members) {
             const members = workspaceManifest.workspace.members;
+            if ((_b = workspaceManifest.package) === null || _b === void 0 ? void 0 : _b.name) {
+                versionsMap.set(workspaceManifest.package.name, version);
+            }
+            else {
+                logger_1.logger.warn('No workspace manifest package name found');
+            }
             logger_1.logger.info(`found workspace with ${members.length} members, upgrading all`);
+            // Collect submodule names to update
+            const manifestsByPath = new Map();
             for (const member of members) {
-                manifestPaths.push(`${member}/Cargo.toml`);
+                const manifestPath = `${member}/Cargo.toml`;
+                const manifestContent = await this.getContent(manifestPath);
+                if (!manifestContent) {
+                    logger_1.logger.warn(`member ${member} declared but did not find Cargo.toml`);
+                    continue;
+                }
+                const manifest = common_1.parseCargoManifest(manifestContent.parsedContent);
+                manifestsByPath.set(manifestPath, manifestContent);
+                if (!((_c = manifest.package) === null || _c === void 0 ? void 0 : _c.name)) {
+                    logger_1.logger.warn(`member ${member} has no package name`);
+                    continue;
+                }
+                versionsMap.set(manifest.package.name, version);
             }
-            lockPath = 'Cargo.lock';
+            logger_1.logger.info(`updating ${manifestsByPath.size} submodules`);
+            logger_1.logger.debug('versions map:', versionsMap);
+            for (const [manifestPath, manifestContent] of manifestsByPath) {
+                updates.push({
+                    path: this.addPath(manifestPath),
+                    createIfMissing: false,
+                    cachedFileContents: manifestContent,
+                    updater: new cargo_toml_1.CargoToml({
+                        version,
+                        versionsMap,
+                    }),
+                });
+            }
+            // Update root Cargo.toml
+            updates.push({
+                path: this.addPath('Cargo.toml'),
+                createIfMissing: false,
+                updater: new cargo_toml_1.CargoToml({
+                    version,
+                    versionsMap,
+                }),
+            });
         }
         else {
             const manifestPath = this.addPath('Cargo.toml');
             logger_1.logger.info(`single crate found, updating ${manifestPath}`);
-            manifestPaths.push(manifestPath);
-            lockPath = this.addPath('Cargo.lock');
-        }
-        const versionsMap = new Map();
-        versionsMap.set(this.component || '', version);
-        for (const path of manifestPaths) {
             updates.push({
-                path,
+                path: manifestPath,
                 createIfMissing: false,
                 updater: new cargo_toml_1.CargoToml({
                     version,
@@ -67,7 +100,7 @@ class Rust extends base_1.BaseStrategy {
             });
         }
         updates.push({
-            path: lockPath,
+            path: this.addPath('Cargo.lock'),
             createIfMissing: false,
             updater: new cargo_lock_1.CargoLock({
                 version,
@@ -92,28 +125,21 @@ class Rust extends base_1.BaseStrategy {
      */
     async getPackageManifest() {
         if (this.packageManifest === undefined) {
-            this.packageManifest = await this.getManifest(this.addPath('Cargo.toml'));
+            this.packageManifest = await this.getManifest('Cargo.toml');
         }
         return this.packageManifest;
     }
-    /**
-     * @returns the workspace's manifest, ie. `Cargo.toml` (top-level)
-     */
-    async getWorkspaceManifest() {
-        if (this.workspaceManifest === undefined) {
-            this.workspaceManifest = await this.getManifest('Cargo.toml');
-        }
-        return this.workspaceManifest;
-    }
-    async getManifest(path) {
-        let content;
+    async getContent(path) {
         try {
-            content = await this.github.getFileContentsOnBranch(path, this.targetBranch);
+            return await this.github.getFileContentsOnBranch(this.addPath(path), this.targetBranch);
         }
         catch (e) {
             return null;
         }
-        return common_1.parseCargoManifest(content.parsedContent);
+    }
+    async getManifest(path) {
+        const content = await this.getContent(path);
+        return content ? common_1.parseCargoManifest(content.parsedContent) : null;
     }
 }
 exports.Rust = Rust;

package/build/src/updaters/composite.d.ts

@@ -1,10 +1,10 @@
-import { Updater } from '../update';
+import { Updater, Update } from '../update';
 /**
  * The CompositeUpdater chains 0...n updaters and updates
  * the content in order.
  */
 export declare class CompositeUpdater implements Updater {
-    updaters: Updater[];
+    readonly updaters: Updater[];
     /**
      * Instantiate a new CompositeUpdater
      * @param {Updater[]} updaters The updaters to chain together
@@ -17,3 +17,4 @@ export declare class CompositeUpdater implements Updater {
      */
     updateContent(content: string | undefined): string;
 }
+export declare function mergeUpdates(updates: Update[]): Update[];

package/build/src/updaters/composite.js

@@ -13,7 +13,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CompositeUpdater = void 0;
+exports.mergeUpdates = exports.CompositeUpdater = void 0;
 /**
  * The CompositeUpdater chains 0...n updaters and updates
  * the content in order.
@@ -39,4 +39,27 @@ class CompositeUpdater {
     }
 }
 exports.CompositeUpdater = CompositeUpdater;
+function mergeUpdates(updates) {
+    const updatesByPath = {};
+    for (const update of updates) {
+        if (updatesByPath[update.path]) {
+            updatesByPath[update.path].push(update);
+        }
+        else {
+            updatesByPath[update.path] = [update];
+        }
+    }
+    const newUpdates = [];
+    for (const path in updatesByPath) {
+        const update = updatesByPath[path];
+        const updaters = update.map(u => u.updater);
+        newUpdates.push({
+            path,
+            createIfMissing: update[0].createIfMissing,
+            updater: updaters.length === 1 ? updaters[0] : new CompositeUpdater(...updaters),
+        });
+    }
+    return newUpdates;
+}
+exports.mergeUpdates = mergeUpdates;
 //# sourceMappingURL=composite.js.map

package/build/src/updaters/generic.d.ts

@@ -0,0 +1,32 @@
+import { DefaultUpdater } from './default';
+/**
+ * The Generic updater looks for well known patterns and replaces
+ * content. The well known patterns are:
+ *
+ * 1. `x-release-please-version` if this string is found on the line,
+ *    then replace a semver-looking string on that line with the next
+ *    version
+ * 2. `x-release-please-major` if this string is found on the line,
+ *    then replace an integer looking value with the the next version's
+ *    major
+ * 3. `x-release-please-minor` if this string is found on the line,
+ *    then replace an integer looking value with the the next version's
+ *    minor
+ * 4. `x-release-please-patch` if this string is found on the line,
+ *    then replace an integer looking value with the the next version's
+ *    patch
+ *
+ * You can also use a block-based replacement. Content between the
+ * opening `x-release-please-start-version` and `x-release-please-end` will
+ * be considered for version replacement. You can also open these blocks
+ * with `x-release-please-start-<major|minor|patch>` to replace single
+ * numbers
+ */
+export declare class Generic extends DefaultUpdater {
+    /**
+     * Given initial file contents, return updated contents.
+     * @param {string} content The initial content
+     * @returns {string} The updated content
+     */
+    updateContent(content: string | undefined): string;
+}

package/build/src/updaters/generic.js

@@ -0,0 +1,110 @@
+"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.Generic = void 0;
+const default_1 = require("./default");
+const logger_1 = require("../util/logger");
+const VERSION_REGEX = /(?<major>\d+)\.(?<minor>\d+)\.(?<patch>\d+)(-(?<preRelease>[\w.]+))?(\+(?<build>[-\w.]+))?/;
+const SINGLE_VERSION_REGEX = /\b\d+\b/;
+const INLINE_UPDATE_REGEX = /x-release-please-(?<scope>major|minor|patch|version)/;
+const BLOCK_START_REGEX = /x-release-please-start-(?<scope>major|minor|patch|version)/;
+const BLOCK_END_REGEX = /x-release-please-end/;
+/**
+ * The Generic updater looks for well known patterns and replaces
+ * content. The well known patterns are:
+ *
+ * 1. `x-release-please-version` if this string is found on the line,
+ *    then replace a semver-looking string on that line with the next
+ *    version
+ * 2. `x-release-please-major` if this string is found on the line,
+ *    then replace an integer looking value with the the next version's
+ *    major
+ * 3. `x-release-please-minor` if this string is found on the line,
+ *    then replace an integer looking value with the the next version's
+ *    minor
+ * 4. `x-release-please-patch` if this string is found on the line,
+ *    then replace an integer looking value with the the next version's
+ *    patch
+ *
+ * You can also use a block-based replacement. Content between the
+ * opening `x-release-please-start-version` and `x-release-please-end` will
+ * be considered for version replacement. You can also open these blocks
+ * with `x-release-please-start-<major|minor|patch>` to replace single
+ * numbers
+ */
+class Generic extends default_1.DefaultUpdater {
+    /**
+     * Given initial file contents, return updated contents.
+     * @param {string} content The initial content
+     * @returns {string} The updated content
+     */
+    updateContent(content) {
+        if (!content) {
+            return '';
+        }
+        const newLines = [];
+        let blockScope;
+        function replaceVersion(line, scope, version) {
+            switch (scope) {
+                case 'major':
+                    newLines.push(line.replace(SINGLE_VERSION_REGEX, `${version.major}`));
+                    return;
+                case 'minor':
+                    newLines.push(line.replace(SINGLE_VERSION_REGEX, `${version.minor}`));
+                    return;
+                case 'patch':
+                    newLines.push(line.replace(SINGLE_VERSION_REGEX, `${version.patch}`));
+                    return;
+                case 'version':
+                    newLines.push(line.replace(VERSION_REGEX, version.toString()));
+                    return;
+                default:
+                    logger_1.logger.warn(`unknown block scope: ${scope}`);
+                    newLines.push(line);
+            }
+        }
+        content.split(/\r?\n/).forEach(line => {
+            var _a, _b;
+            let match = line.match(INLINE_UPDATE_REGEX);
+            if (match) {
+                // replace inline versions
+                replaceVersion(line, (((_a = match.groups) === null || _a === void 0 ? void 0 : _a.scope) || 'version'), this.version);
+            }
+            else if (blockScope) {
+                // in a block, so try to replace versions
+                replaceVersion(line, blockScope, this.version);
+                if (line.match(BLOCK_END_REGEX)) {
+                    blockScope = undefined;
+                }
+            }
+            else {
+                // look for block start line
+                match = line.match(BLOCK_START_REGEX);
+                if (match) {
+                    if ((_b = match.groups) === null || _b === void 0 ? void 0 : _b.scope) {
+                        blockScope = match.groups.scope;
+                    }
+                    else {
+                        blockScope = 'version';
+                    }
+                }
+                newLines.push(line);
+            }
+        });
+        return newLines.join('\n');
+    }
+}
+exports.Generic = Generic;
+//# sourceMappingURL=generic.js.map

package/build/src/updaters/rust/cargo-toml.js

@@ -28,7 +28,6 @@ class CargoToml extends default_1.DefaultUpdater {
      * @returns {string} The updated content
      */
     updateContent(content) {
-        var _a;
         let payload = content;
         if (!this.versionsMap) {
             throw new Error('updateContent called with no versions');
@@ -39,12 +38,8 @@ class CargoToml extends default_1.DefaultUpdater {
             logger_1.logger.error(msg);
             throw new Error(msg);
         }
+        payload = toml_edit_1.replaceTomlValue(payload, ['package', 'version'], this.version.toString());
         for (const [pkgName, pkgVersion] of this.versionsMap) {
-            if (parsed.package.name === pkgName) {
-                logger_1.logger.info(`updating own version from ${(_a = parsed.package) === null || _a === void 0 ? void 0 : _a.version} to ${pkgVersion}`);
-                payload = toml_edit_1.replaceTomlValue(payload, ['package', 'version'], pkgVersion.toString());
-                continue; // to next [pkgName, pkgVersion] pair
-            }
             for (const depKind of common_1.DEP_KINDS) {
                 const deps = parsed[depKind];
                 if (!deps) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "release-please",
-  "version": "13.0.0",
+  "version": "13.1.1",
   "description": "generate release PRs based on the conventionalcommits.org spec",
   "main": "./build/src/index.js",
   "bin": "./build/src/bin/release-please.js",