release-please 13.0.1 → 13.2.0

package/CHANGELOG.md

@@ -4,6 +4,39 @@
 
 [1]: https://www.npmjs.com/package/release-please?activeTab=versions
 
+## [13.2.0](https://github.com/googleapis/release-please/compare/v13.1.1...v13.2.0) (2022-01-11)
+
+
+### Features
+
+* allow prerelease releases on Github ([#1181](https://github.com/googleapis/release-please/issues/1181)) ([267dbfc](https://github.com/googleapis/release-please/commit/267dbfc58a50cde7ffa378b357df62066a1218c9))
+
+
+### Bug Fixes
+
+* java snapshots should update all files with :current annotations ([#1204](https://github.com/googleapis/release-please/issues/1204)) ([6f3ae8b](https://github.com/googleapis/release-please/commit/6f3ae8b58afb6673dab2f49daa3d17fbbbef352c))
+
+### [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)
 
 

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/bin/release-please.d.ts

@@ -39,6 +39,7 @@ interface ManifestConfigArgs {
 }
 interface ReleaseArgs {
     draft?: boolean;
+    prerelease?: boolean;
     releaseLabel?: string;
     label?: string;
 }

package/build/src/bin/release-please.js

@@ -76,6 +76,12 @@ function releaseOptions(yargs) {
             'tag creation upon "un-drafting" the release.',
         type: 'boolean',
         default: false,
+    })
+        .option('prerelease', {
+        describe: 'mark release that have prerelease versions ' +
+            'as as a prerelease on Github',
+        type: 'boolean',
+        default: false,
     })
         .option('label', {
         default: 'autorelease: pending',
@@ -316,6 +322,7 @@ const createReleaseCommand = {
                 component: argv.component,
                 packageName: argv.packageName,
                 draft: argv.draft,
+                prerelease: argv.prerelease,
                 includeComponentInTag: argv.monorepoTags,
             }, extractManifestOptions(argv), argv.path);
         }
@@ -419,6 +426,7 @@ const bootstrapCommand = {
             component: argv.component,
             packageName: argv.packageName,
             draft: argv.draft,
+            prerelease: argv.prerelease,
             draftPullRequest: argv.draftPullRequest,
             bumpMinorPreMajor: argv.bumpMinorPreMajor,
             bumpPatchForMinorPreMajor: argv.bumpPatchForMinorPreMajor,

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.d.ts

@@ -46,6 +46,10 @@ interface ReleaseIteratorOptions {
 interface TagIteratorOptions {
     maxResults?: number;
 }
+export interface ReleaseOptions {
+    draft?: boolean;
+    prerelease?: boolean;
+}
 export interface GitHubRelease {
     name?: string;
     tagName: string;
@@ -306,13 +310,11 @@ export declare class GitHub {
      * Create a GitHub release
      *
      * @param {Release} release Release parameters
-     * @param {boolean} draft Whether or not to create the release as a draft
+     * @param {ReleaseOptions} options Release option parameters
      * @throws {DuplicateReleaseError} if the release tag already exists
      * @throws {GitHubAPIError} on other API errors
      */
-    createRelease: (release: Release, options?: {
-        draft?: boolean | undefined;
-    } | undefined) => Promise<GitHubRelease>;
+    createRelease: (release: Release, options?: ReleaseOptions | undefined) => Promise<GitHubRelease>;
     /**
      * Makes a comment on a issue/pull request.
      *

package/build/src/github.js

@@ -293,18 +293,20 @@ class GitHub {
          * Create a GitHub release
          *
          * @param {Release} release Release parameters
-         * @param {boolean} draft Whether or not to create the release as a draft
+         * @param {ReleaseOptions} options Release option parameters
          * @throws {DuplicateReleaseError} if the release tag already exists
          * @throws {GitHubAPIError} on other API errors
          */
         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(),
                 body: release.notes,
                 sha: release.sha,
                 draft: !!options.draft,
+                prerelease: !!options.prerelease,
             });
             return {
                 name: resp.data.name || undefined,
@@ -650,39 +652,39 @@ class GitHub {
         logger_1.logger.debug(`Fetching ${states} pull requests on branch ${targetBranch} with cursor ${cursor}`);
         const response = await this.graphqlRequest({
             query: `query mergedPullRequests($owner: String!, $repo: String!, $num: Int!, $maxFilesChanged: Int, $targetBranch: String!, $states: [PullRequestState!], $cursor: String) {
-          repository(owner: $owner, name: $repo) {
-            pullRequests(first: $num, after: $cursor, baseRefName: $targetBranch, states: $states, orderBy: {field: CREATED_AT, direction: DESC}) {
-              nodes {
-                number
-                title
-                baseRefName
-                headRefName
-                labels(first: 10) {
-                  nodes {
-                    name
-                  }
+        repository(owner: $owner, name: $repo) {
+          pullRequests(first: $num, after: $cursor, baseRefName: $targetBranch, states: $states, orderBy: {field: CREATED_AT, direction: DESC}) {
+            nodes {
+              number
+              title
+              baseRefName
+              headRefName
+              labels(first: 10) {
+                nodes {
+                  name
                 }
-                body
-                mergeCommit {
-                  oid
+              }
+              body
+              mergeCommit {
+                oid
+              }
+              files(first: $maxFilesChanged) {
+                nodes {
+                  path
                 }
-                files(first: $maxFilesChanged) {
-                  nodes {
-                    path
-                  }
-                  pageInfo {
-                    endCursor
-                    hasNextPage
-                  }
+                pageInfo {
+                  endCursor
+                  hasNextPage
                 }
               }
-              pageInfo {
-                endCursor
-                hasNextPage
-              }
+            }
+            pageInfo {
+              endCursor
+              hasNextPage
             }
           }
-        }`,
+        }
+      }`,
             cursor,
             owner: this.repository.owner,
             repo: this.repository.repo,

package/build/src/manifest.d.ts

@@ -16,6 +16,7 @@ export interface ReleaserConfig {
     releaseAs?: string;
     skipGithubRelease?: boolean;
     draft?: boolean;
+    prerelease?: boolean;
     draftPullRequest?: boolean;
     component?: string;
     packageName?: string;
@@ -34,8 +35,9 @@ export interface CandidateReleasePullRequest {
 }
 export interface CandidateRelease extends Release {
     pullRequest: PullRequest;
-    draft?: boolean;
     path: string;
+    draft?: boolean;
+    prerelease?: boolean;
 }
 interface ReleaserConfigJson {
     'release-type'?: ReleaseType;
@@ -45,6 +47,7 @@ interface ReleaserConfigJson {
     'release-as'?: string;
     'skip-github-release'?: boolean;
     draft?: boolean;
+    prerelease?: boolean;
     'draft-pull-request'?: boolean;
     label?: string;
     'release-label'?: string;
@@ -66,6 +69,7 @@ export interface ManifestOptions {
     labels?: string[];
     releaseLabels?: string[];
     draft?: boolean;
+    prerelease?: boolean;
     draftPullRequest?: boolean;
 }
 interface ReleaserPackageConfig extends ReleaserConfigJson {
@@ -116,6 +120,7 @@ export declare class Manifest {
     private bootstrapSha?;
     private lastReleaseSha?;
     private draft?;
+    private prerelease?;
     private draftPullRequest?;
     /**
      * Create a Manifest from explicit config in code. This assumes that the

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 || '',
@@ -438,6 +439,9 @@ class Manifest {
                         path,
                         pullRequest,
                         draft: (_a = config.draft) !== null && _a !== void 0 ? _a : this.draft,
+                        prerelease: config.prerelease &&
+                            (!!release.tag.version.preRelease ||
+                                release.tag.version.major === 0),
                     });
                 }
             }
@@ -487,6 +491,7 @@ class Manifest {
     async createRelease(release) {
         const githubRelease = await this.github.createRelease(release, {
             draft: release.draft,
+            prerelease: release.prerelease,
         });
         // comment on pull request
         const comment = `:robot: Release is at ${githubRelease.url} :sunflower:`;
@@ -552,6 +557,7 @@ function extractReleaserConfig(config) {
         releaseAs: config['release-as'],
         skipGithubRelease: config['skip-github-release'],
         draft: config.draft,
+        prerelease: config.prerelease,
         draftPullRequest: config['draft-pull-request'],
         component: config['component'],
         packageName: config['package-name'],
@@ -695,7 +701,7 @@ async function latestReleaseVersion(github, targetBranch, prefix, pullRequestTit
     return candidateTagVersion.sort((a, b) => b.compare(a))[0];
 }
 function mergeReleaserConfig(defaultConfig, pathConfig) {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o;
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p;
     return {
         releaseType: (_b = (_a = pathConfig.releaseType) !== null && _a !== void 0 ? _a : defaultConfig.releaseType) !== null && _b !== void 0 ? _b : 'node',
         bumpMinorPreMajor: (_c = pathConfig.bumpMinorPreMajor) !== null && _c !== void 0 ? _c : defaultConfig.bumpMinorPreMajor,
@@ -705,10 +711,11 @@ function mergeReleaserConfig(defaultConfig, pathConfig) {
         releaseAs: (_g = pathConfig.releaseAs) !== null && _g !== void 0 ? _g : defaultConfig.releaseAs,
         skipGithubRelease: (_h = pathConfig.skipGithubRelease) !== null && _h !== void 0 ? _h : defaultConfig.skipGithubRelease,
         draft: (_j = pathConfig.draft) !== null && _j !== void 0 ? _j : defaultConfig.draft,
-        component: (_k = pathConfig.component) !== null && _k !== void 0 ? _k : defaultConfig.component,
-        packageName: (_l = pathConfig.packageName) !== null && _l !== void 0 ? _l : defaultConfig.packageName,
-        versionFile: (_m = pathConfig.versionFile) !== null && _m !== void 0 ? _m : defaultConfig.versionFile,
-        extraFiles: (_o = pathConfig.extraFiles) !== null && _o !== void 0 ? _o : defaultConfig.extraFiles,
+        prerelease: (_k = pathConfig.prerelease) !== null && _k !== void 0 ? _k : defaultConfig.prerelease,
+        component: (_l = pathConfig.component) !== null && _l !== void 0 ? _l : defaultConfig.component,
+        packageName: (_m = pathConfig.packageName) !== null && _m !== void 0 ? _m : defaultConfig.packageName,
+        versionFile: (_o = pathConfig.versionFile) !== null && _o !== void 0 ? _o : defaultConfig.versionFile,
+        extraFiles: (_p = pathConfig.extraFiles) !== null && _p !== void 0 ? _p : defaultConfig.extraFiles,
     };
 }
 /**

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,20 +5,19 @@ 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[];
+interface JavaBuildUpdatesOption extends BuildUpdatesOptions {
+    isSnapshot?: boolean;
 }
 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;
     protected buildVersionsMap(): Promise<VersionsMap>;
     protected getVersionsContent(): Promise<GitHubFileContents>;
-    protected buildUpdates(options: BuildUpdatesOptions): Promise<Update[]>;
+    protected buildUpdates(options: JavaBuildUpdatesOption): Promise<Update[]>;
     protected updateVersionsMap(versionsMap: VersionsMap, conventionalCommits: ConventionalCommit[]): Promise<VersionsMap>;
     protected initialReleaseVersion(): Version;
 }

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 = []) {
@@ -79,26 +78,24 @@ class JavaYoshi extends base_1.BaseStrategy {
         const branchName = component
             ? branch_name_1.BranchName.ofComponentTargetBranch(component, this.targetBranch)
             : branch_name_1.BranchName.ofTargetBranch(this.targetBranch);
+        const notes = '### Updating meta-information for bleeding-edge SNAPSHOT release.';
         const pullRequestBody = new pull_request_body_1.PullRequestBody([
             {
                 component,
                 version: newVersion,
-                notes: '### Updating meta-information for bleeding-edge SNAPSHOT release.',
+                notes,
             },
         ]);
+        const updates = await this.buildUpdates({
+            newVersion,
+            versionsMap,
+            changelogEntry: notes,
+            isSnapshot: true,
+        });
         return {
             title: pullRequestTitle,
             body: pullRequestBody,
-            updates: [
-                {
-                    path: this.addPath('versions.txt'),
-                    createIfMissing: false,
-                    updater: new versions_manifest_1.VersionsManifest({
-                        version: newVersion,
-                        versionsMap,
-                    }),
-                },
-            ],
+            updates,
             labels: [],
             headRefName: branchName.toString(),
             version: newVersion,
@@ -150,6 +147,7 @@ class JavaYoshi extends base_1.BaseStrategy {
                 updater: new java_update_1.JavaUpdate({
                     version,
                     versionsMap,
+                    isSnapshot: options.isSnapshot,
                 }),
             });
         });
@@ -161,6 +159,7 @@ class JavaYoshi extends base_1.BaseStrategy {
                 updater: new java_update_1.JavaUpdate({
                     version,
                     versionsMap,
+                    isSnapshot: options.isSnapshot,
                 }),
             });
         });
@@ -172,6 +171,7 @@ class JavaYoshi extends base_1.BaseStrategy {
                 updater: new java_update_1.JavaUpdate({
                     version,
                     versionsMap,
+                    isSnapshot: options.isSnapshot,
                 }),
             });
         });
@@ -182,17 +182,20 @@ class JavaYoshi extends base_1.BaseStrategy {
                 updater: new java_update_1.JavaUpdate({
                     version,
                     versionsMap,
+                    isSnapshot: options.isSnapshot,
                 }),
             });
         });
-        updates.push({
-            path: this.addPath(this.changelogPath),
-            createIfMissing: true,
-            updater: new changelog_1.Changelog({
-                version,
-                changelogEntry: options.changelogEntry,
-            }),
-        });
+        if (!options.isSnapshot) {
+            updates.push({
+                path: this.addPath(this.changelogPath),
+                createIfMissing: true,
+                updater: new changelog_1.Changelog({
+                    version,
+                    changelogEntry: options.changelogEntry,
+                }),
+            });
+        }
         return updates;
     }
     async updateVersionsMap(versionsMap, conventionalCommits) {

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/java/java-update.d.ts

@@ -1,10 +1,15 @@
-import { DefaultUpdater } from '../default';
+import { DefaultUpdater, UpdateOptions } from '../default';
+interface JavaUpdateOptions extends UpdateOptions {
+    isSnapshot?: boolean;
+}
 /**
  * Updates a file annotated with region markers. These region markers are
  * either denoted inline with `{x-version-update:<component-name>:current|released}`
  * or with a `{x-version-update-start:<component-name>}` and `{x-version-update-end}`.
  */
 export declare class JavaUpdate extends DefaultUpdater {
+    isSnapshot: boolean;
+    constructor(options: JavaUpdateOptions);
     /**
      * Given initial file contents, return updated contents.
      * @param {string} content The initial content
@@ -12,3 +17,4 @@ export declare class JavaUpdate extends DefaultUpdater {
      */
     updateContent(content: string): string;
 }
+export {};

package/build/src/updaters/java/java-update.js

@@ -26,6 +26,10 @@ const VERSION_REGEX = /\d+\.\d+\.\d+(-\w+(\.\d+)?)?(-SNAPSHOT)?/;
  * or with a `{x-version-update-start:<component-name>}` and `{x-version-update-end}`.
  */
 class JavaUpdate extends default_1.DefaultUpdater {
+    constructor(options) {
+        super(options);
+        this.isSnapshot = !!options.isSnapshot;
+    }
     /**
      * Given initial file contents, return updated contents.
      * @param {string} content The initial content
@@ -40,7 +44,7 @@ class JavaUpdate extends default_1.DefaultUpdater {
         let blockPackageName = null;
         content.split(/\r?\n/).forEach(line => {
             let match = line.match(INLINE_UPDATE_REGEX);
-            if (match) {
+            if (match && (!this.isSnapshot || match[2] === 'current')) {
                 const newVersion = this.versionsMap.get(match[1]);
                 if (newVersion) {
                     newLines.push(line.replace(VERSION_REGEX, newVersion.toString()));
@@ -63,7 +67,7 @@ class JavaUpdate extends default_1.DefaultUpdater {
             }
             else {
                 match = line.match(BLOCK_START_REGEX);
-                if (match) {
+                if (match && (!this.isSnapshot || match[2] === 'current')) {
                     blockPackageName = match[1];
                 }
                 newLines.push(line);

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.1",
+  "version": "13.2.0",
   "description": "generate release PRs based on the conventionalcommits.org spec",
   "main": "./build/src/index.js",
   "bin": "./build/src/bin/release-please.js",
@@ -50,7 +50,7 @@
     "c8": "^7.0.0",
     "chai": "^4.2.0",
     "cross-env": "^7.0.0",
-    "gts": "^2.0.0",
+    "gts": "^3.0.0",
     "mocha": "^8.0.0",
     "nock": "^13.0.0",
     "sinon": "12.0.1",