release-please 13.4.14 → 13.6.0

package/CHANGELOG.md

@@ -4,6 +4,34 @@
 
 [1]: https://www.npmjs.com/package/release-please?activeTab=versions
 
+## [13.6.0](https://github.com/googleapis/release-please/compare/v13.5.0...v13.6.0) (2022-03-16)
+
+
+### Features
+
+* add linked-versions plugin for grouping components ([#1327](https://github.com/googleapis/release-please/issues/1327)) ([f398bdf](https://github.com/googleapis/release-please/commit/f398bdffdae69772c61a82cd7158cca3478c2110))
+* introduce generic json updater ([#1332](https://github.com/googleapis/release-please/issues/1332)) ([ecbfcf0](https://github.com/googleapis/release-please/commit/ecbfcf03f7854ced3ace5eafd95f7872ddee1d14))
+* introduce generic xml updater ([#1337](https://github.com/googleapis/release-please/issues/1337)) ([02ef78b](https://github.com/googleapis/release-please/commit/02ef78b4d6a855236ff80fc139fd00a46f88d445))
+
+## [13.5.0](https://github.com/googleapis/release-please/compare/v13.4.15...v13.5.0) (2022-03-08)
+
+
+### Features
+
+* **ocaml:** update opam `project.opam.locked` files ([#1325](https://github.com/googleapis/release-please/issues/1325)) ([858199e](https://github.com/googleapis/release-please/commit/858199e4fac71ce2574c4195b85dc4e8bf26e0f7))
+
+
+### Bug Fixes
+
+* fix regex for parsing major version update ([#1330](https://github.com/googleapis/release-please/issues/1330)) ([afadec9](https://github.com/googleapis/release-please/commit/afadec95aa62aa32372512455326c4cdf8943f70))
+
+### [13.4.15](https://github.com/googleapis/release-please/compare/v13.4.14...v13.4.15) (2022-03-02)
+
+
+### Bug Fixes
+
+* tagging many GitHub releases should not require a file touched check ([#1321](https://github.com/googleapis/release-please/issues/1321)) ([ab99242](https://github.com/googleapis/release-please/commit/ab9924215e68838e6ec62d283b5712cbff6e6a4c))
+
 ### [13.4.14](https://github.com/googleapis/release-please/compare/v13.4.13...v13.4.14) (2022-03-01)
 
 

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

@@ -332,7 +332,18 @@ const createReleaseCommand = {
         }
         if (argv.dryRun) {
             const releases = await manifest.buildReleases();
-            logger_1.logger.info(releases);
+            logger_1.logger.info(`Would tag ${releases.length} releases:`);
+            for (const release of releases) {
+                logger_1.logger.info({
+                    name: release.name,
+                    tag: release.tag.toString(),
+                    notes: release.notes,
+                    sha: release.sha,
+                    draft: release.draft,
+                    prerelease: release.prerelease,
+                    pullNumber: release.pullRequest.number,
+                });
+            }
         }
         else {
             const releaseNumbers = await manifest.createReleases();

package/build/src/factory.js

@@ -39,6 +39,7 @@ const node_workspace_1 = require("./plugins/node-workspace");
 const cargo_workspace_1 = require("./plugins/cargo-workspace");
 const github_1 = require("./changelog-notes/github");
 const default_2 = require("./changelog-notes/default");
+const linked_versions_1 = require("./plugins/linked-versions");
 // Factory shared by GitHub Action and CLI for creating Release PRs
 // and GitHub Releases:
 // add any new releasers you create to this type as well as the `releasers`
@@ -191,6 +192,14 @@ function buildVersioningStrategy(options) {
     }
 }
 function buildPlugin(options) {
+    if (typeof options.type === 'object') {
+        switch (options.type.type) {
+            case 'linked-versions':
+                return new linked_versions_1.LinkedVersions(options.github, options.targetBranch, options.repositoryConfig, options.type.groupName, options.type.components);
+            default:
+                throw new Error(`Unknown plugin type: ${options.type}`);
+        }
+    }
     switch (options.type) {
         case 'cargo-workspace':
             return new cargo_workspace_1.CargoWorkspace(options.github, options.targetBranch, options.repositoryConfig, options);

package/build/src/manifest.d.ts

@@ -5,6 +5,17 @@ import { PullRequest } from './pull-request';
 import { ReleasePullRequest } from './release-pull-request';
 import { ReleaseType, VersioningStrategyType, ChangelogNotesType } from './factory';
 import { Release } from './release';
+declare type ExtraJsonFile = {
+    type: 'json';
+    path: string;
+    jsonpath: string;
+};
+declare type ExtraXmlFile = {
+    type: 'xml';
+    path: string;
+    xpath: string;
+};
+export declare type ExtraFile = string | ExtraJsonFile | ExtraXmlFile;
 /**
  * These are configurations provided to each strategy per-path.
  */
@@ -27,7 +38,7 @@ export interface ReleaserConfig {
     changelogPath?: string;
     changelogType?: ChangelogNotesType;
     versionFile?: string;
-    extraFiles?: string[];
+    extraFiles?: ExtraFile[];
 }
 export interface CandidateReleasePullRequest {
     path: string;
@@ -80,7 +91,13 @@ interface ReleaserPackageConfig extends ReleaserConfigJson {
     component?: string;
     'changelog-path'?: string;
 }
-export declare type PluginType = 'node-workspace' | 'cargo-workspace';
+declare type DirectPluginType = 'node-workspace' | 'cargo-workspace';
+interface LinkedVersionPluginConfig {
+    type: 'linked-versions';
+    groupName: string;
+    components: string[];
+}
+export declare type PluginType = DirectPluginType | LinkedVersionPluginConfig;
 /**
  * This is the schema of the manifest config json
  */

package/build/src/manifest.js

@@ -270,33 +270,54 @@ class Manifest {
             includeEmpty: true,
             packagePaths: Object.keys(this.repositoryConfig),
         });
-        const commitsPerPath = cs.split(commits);
-        let newReleasePullRequests = [];
+        const splitCommits = cs.split(commits);
+        // limit paths to ones since the last release
+        const commitsPerPath = {};
         for (const path in this.repositoryConfig) {
-            const config = this.repositoryConfig[path];
-            logger_1.logger.info(`Building candidate release pull request for path: ${path}`);
-            logger_1.logger.debug(`type: ${config.releaseType}`);
-            logger_1.logger.debug(`targetBranch: ${this.targetBranch}`);
-            const pathCommits = commitsAfterSha(path === exports.ROOT_PROJECT_PATH ? commits : commitsPerPath[path], releaseShasByPath[path]);
-            logger_1.logger.debug(`commits: ${pathCommits.length}`);
-            const latestReleasePullRequest = releasePullRequestsBySha[releaseShasByPath[path]];
-            if (!latestReleasePullRequest) {
-                logger_1.logger.warn('No latest release pull request found.');
-            }
-            const strategy = strategiesByPath[path];
-            let latestRelease = releasesByPath[path];
+            commitsPerPath[path] = commitsAfterSha(path === exports.ROOT_PROJECT_PATH ? commits : splitCommits[path], releaseShasByPath[path]);
+        }
+        // backfill latest release tags from manifest
+        for (const path in this.repositoryConfig) {
+            const latestRelease = releasesByPath[path];
             if (!latestRelease &&
                 this.releasedVersions[path] &&
                 this.releasedVersions[path].toString() !== '0.0.0') {
                 const version = this.releasedVersions[path];
+                const strategy = strategiesByPath[path];
                 const component = await strategy.getComponent();
                 logger_1.logger.info(`No latest release found for path: ${path}, component: ${component}, but a previous version (${version.toString()}) was specified in the manifest.`);
-                latestRelease = {
+                releasesByPath[path] = {
                     tag: new tag_name_1.TagName(version, component),
                     sha: '',
                     notes: '',
                 };
             }
+        }
+        // Build plugins
+        const plugins = this.plugins.map(pluginType => factory_1.buildPlugin({
+            type: pluginType,
+            github: this.github,
+            targetBranch: this.targetBranch,
+            repositoryConfig: this.repositoryConfig,
+        }));
+        let strategies = strategiesByPath;
+        for (const plugin of plugins) {
+            strategies = await plugin.preconfigure(strategies, commitsPerPath, releasesByPath);
+        }
+        let newReleasePullRequests = [];
+        for (const path in this.repositoryConfig) {
+            const config = this.repositoryConfig[path];
+            logger_1.logger.info(`Building candidate release pull request for path: ${path}`);
+            logger_1.logger.debug(`type: ${config.releaseType}`);
+            logger_1.logger.debug(`targetBranch: ${this.targetBranch}`);
+            const pathCommits = commitsPerPath[path];
+            logger_1.logger.debug(`commits: ${pathCommits.length}`);
+            const latestReleasePullRequest = releasePullRequestsBySha[releaseShasByPath[path]];
+            if (!latestReleasePullRequest) {
+                logger_1.logger.warn('No latest release pull request found.');
+            }
+            const strategy = strategies[path];
+            const latestRelease = releasesByPath[path];
             const releasePullRequest = await strategy.buildReleasePullRequest(pathCommits, latestRelease, (_a = config.draftPullRequest) !== null && _a !== void 0 ? _a : this.draftPullRequest, this.labels);
             if (releasePullRequest) {
                 if (releasePullRequest.version) {
@@ -318,13 +339,6 @@ class Manifest {
                 });
             }
         }
-        // Build plugins
-        const plugins = this.plugins.map(pluginType => factory_1.buildPlugin({
-            type: pluginType,
-            github: this.github,
-            targetBranch: this.targetBranch,
-            repositoryConfig: this.repositoryConfig,
-        }));
         // Combine pull requests into 1 unless configured for separate
         // pull requests
         if (!this.separatePullRequests) {
@@ -454,29 +468,11 @@ class Manifest {
         const generator = await this.findMergedReleasePullRequests();
         const releases = [];
         for await (const pullRequest of generator) {
-            logger_1.logger.info('Looking at files touched by path');
-            const cs = new commit_split_1.CommitSplit({
-                includeEmpty: true,
-                packagePaths: Object.keys(this.repositoryConfig),
-            });
-            const commits = [
-                {
-                    sha: pullRequest.sha,
-                    message: pullRequest.title,
-                    files: pullRequest.files,
-                },
-            ];
-            const commitsPerPath = cs.split(commits);
             for (const path in this.repositoryConfig) {
                 const config = this.repositoryConfig[path];
                 logger_1.logger.info(`Building release for path: ${path}`);
                 logger_1.logger.debug(`type: ${config.releaseType}`);
                 logger_1.logger.debug(`targetBranch: ${this.targetBranch}`);
-                const pathCommits = path === exports.ROOT_PROJECT_PATH ? commits : commitsPerPath[path];
-                if (!pathCommits || pathCommits.length === 0) {
-                    logger_1.logger.info(`No commits for path: ${path}, skipping`);
-                    continue;
-                }
                 const strategy = strategiesByPath[path];
                 const release = await strategy.buildRelease(pullRequest);
                 if (release) {
@@ -490,6 +486,9 @@ class Manifest {
                                 release.tag.version.major === 0),
                     });
                 }
+                else {
+                    logger_1.logger.info(`No release necessary for path: ${path}`);
+                }
             }
         }
         return releases;

package/build/src/plugin.d.ts

@@ -1,5 +1,8 @@
 import { GitHub } from './github';
 import { CandidateReleasePullRequest, RepositoryConfig } from './manifest';
+import { Strategy } from './strategy';
+import { Commit } from './commit';
+import { Release } from './release';
 /**
  * A plugin runs after a repository manifest has built candidate
  * pull requests and can make updates that span across multiple
@@ -16,5 +19,11 @@ export declare abstract class ManifestPlugin {
      * @param {CandidateReleasePullRequest[]} pullRequests Candidate pull requests
      * @returns {CandidateReleasePullRequest[]} Updated pull requests
      */
-    abstract run(pullRequests: CandidateReleasePullRequest[]): Promise<CandidateReleasePullRequest[]>;
+    run(pullRequests: CandidateReleasePullRequest[]): Promise<CandidateReleasePullRequest[]>;
+    /**
+     * Pre-configure strategies.
+     * @param {Record<string, Strategy>} strategiesByPath Strategies indexed by path
+     * @returns {Record<string, Strategy>} Updated strategies indexed by path
+     */
+    preconfigure(strategiesByPath: Record<string, Strategy>, _commitsByPath: Record<string, Commit[]>, _releasesByPath: Record<string, Release>): Promise<Record<string, Strategy>>;
 }

package/build/src/plugin.js

@@ -26,6 +26,22 @@ class ManifestPlugin {
         this.targetBranch = targetBranch;
         this.repositoryConfig = repositoryConfig;
     }
+    /**
+     * Post-process candidate pull requests.
+     * @param {CandidateReleasePullRequest[]} pullRequests Candidate pull requests
+     * @returns {CandidateReleasePullRequest[]} Updated pull requests
+     */
+    async run(pullRequests) {
+        return pullRequests;
+    }
+    /**
+     * Pre-configure strategies.
+     * @param {Record<string, Strategy>} strategiesByPath Strategies indexed by path
+     * @returns {Record<string, Strategy>} Updated strategies indexed by path
+     */
+    async preconfigure(strategiesByPath, _commitsByPath, _releasesByPath) {
+        return strategiesByPath;
+    }
 }
 exports.ManifestPlugin = ManifestPlugin;
 //# sourceMappingURL=plugin.js.map

package/build/src/plugins/linked-versions.d.ts

@@ -0,0 +1,29 @@
+import { ManifestPlugin } from '../plugin';
+import { RepositoryConfig, CandidateReleasePullRequest } from '../manifest';
+import { GitHub } from '../github';
+import { Strategy } from '../strategy';
+import { Commit } from '../commit';
+import { Release } from '../release';
+/**
+ * This plugin reconfigures strategies by linking multiple components
+ * together.
+ *
+ * Release notes are broken up using `<summary>`/`<details>` blocks.
+ */
+export declare class LinkedVersions extends ManifestPlugin {
+    private groupName;
+    private components;
+    constructor(github: GitHub, targetBranch: string, repositoryConfig: RepositoryConfig, groupName: string, components: string[]);
+    /**
+     * Pre-configure strategies.
+     * @param {Record<string, Strategy>} strategiesByPath Strategies indexed by path
+     * @returns {Record<string, Strategy>} Updated strategies indexed by path
+     */
+    preconfigure(strategiesByPath: Record<string, Strategy>, commitsByPath: Record<string, Commit[]>, releasesByPath: Record<string, Release>): Promise<Record<string, Strategy>>;
+    /**
+     * Post-process candidate pull requests.
+     * @param {CandidateReleasePullRequest[]} pullRequests Candidate pull requests
+     * @returns {CandidateReleasePullRequest[]} Updated pull requests
+     */
+    run(candidates: CandidateReleasePullRequest[]): Promise<CandidateReleasePullRequest[]>;
+}

package/build/src/plugins/linked-versions.js

@@ -0,0 +1,125 @@
+"use strict";
+// Copyright 2022 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.LinkedVersions = void 0;
+const plugin_1 = require("../plugin");
+const logger_1 = require("../util/logger");
+const factory_1 = require("../factory");
+const merge_1 = require("./merge");
+/**
+ * This plugin reconfigures strategies by linking multiple components
+ * together.
+ *
+ * Release notes are broken up using `<summary>`/`<details>` blocks.
+ */
+class LinkedVersions extends plugin_1.ManifestPlugin {
+    constructor(github, targetBranch, repositoryConfig, groupName, components) {
+        super(github, targetBranch, repositoryConfig);
+        this.groupName = groupName;
+        this.components = new Set(components);
+    }
+    /**
+     * Pre-configure strategies.
+     * @param {Record<string, Strategy>} strategiesByPath Strategies indexed by path
+     * @returns {Record<string, Strategy>} Updated strategies indexed by path
+     */
+    async preconfigure(strategiesByPath, commitsByPath, releasesByPath) {
+        // Find all strategies in the group
+        const groupStrategies = {};
+        for (const path in strategiesByPath) {
+            const strategy = strategiesByPath[path];
+            const component = await strategy.getComponent();
+            if (!component) {
+                continue;
+            }
+            if (this.components.has(component)) {
+                groupStrategies[path] = strategy;
+            }
+        }
+        logger_1.logger.info(`Found ${Object.keys(groupStrategies).length} group components for ${this.groupName}`);
+        const groupVersions = {};
+        const missingReleasePaths = new Set();
+        for (const path in groupStrategies) {
+            const strategy = groupStrategies[path];
+            const latestRelease = releasesByPath[path];
+            const releasePullRequest = await strategy.buildReleasePullRequest(commitsByPath[path], latestRelease);
+            if (releasePullRequest === null || releasePullRequest === void 0 ? void 0 : releasePullRequest.version) {
+                groupVersions[path] = releasePullRequest.version;
+            }
+            else {
+                missingReleasePaths.add(path);
+            }
+        }
+        const versions = Object.values(groupVersions);
+        if (versions.length === 0) {
+            return strategiesByPath;
+        }
+        const primaryVersion = versions.reduce((collector, version) => collector.compare(version) > 0 ? collector : version, versions[0]);
+        const newStrategies = {};
+        for (const path in strategiesByPath) {
+            if (path in groupStrategies) {
+                const component = await strategiesByPath[path].getComponent();
+                logger_1.logger.info(`Replacing strategy for path ${path} with forced version: ${primaryVersion}`);
+                newStrategies[path] = await factory_1.buildStrategy({
+                    ...this.repositoryConfig[path],
+                    github: this.github,
+                    path,
+                    targetBranch: this.targetBranch,
+                    releaseAs: primaryVersion.toString(),
+                });
+                if (missingReleasePaths.has(path)) {
+                    logger_1.logger.debug(`Appending fake commit for path: ${path}`);
+                    commitsByPath[path].push({
+                        sha: '',
+                        message: `chore(${component}): Synchronize ${this.groupName} versions\n\nRelease-As: ${primaryVersion.toString()}`,
+                    });
+                }
+            }
+            else {
+                newStrategies[path] = strategiesByPath[path];
+            }
+        }
+        return newStrategies;
+    }
+    /**
+     * Post-process candidate pull requests.
+     * @param {CandidateReleasePullRequest[]} pullRequests Candidate pull requests
+     * @returns {CandidateReleasePullRequest[]} Updated pull requests
+     */
+    async run(candidates) {
+        const [inScopeCandidates, outOfScopeCandidates] = candidates.reduce((collection, candidate) => {
+            if (!candidate.pullRequest.version) {
+                logger_1.logger.warn('pull request missing version', candidate);
+                return collection;
+            }
+            if (this.components.has(candidate.config.component || '')) {
+                collection[0].push(candidate);
+            }
+            else {
+                collection[1].push(candidate);
+            }
+            return collection;
+        }, [[], []]);
+        // delegate to the merge plugin and add merged pull request
+        if (inScopeCandidates.length > 0) {
+            const merge = new merge_1.Merge(this.github, this.targetBranch, this.repositoryConfig, `chore\${branch}: release ${this.groupName} libraries`);
+            const merged = await merge.run(inScopeCandidates);
+            outOfScopeCandidates.push(...merged);
+        }
+        return outOfScopeCandidates;
+    }
+}
+exports.LinkedVersions = LinkedVersions;
+//# sourceMappingURL=linked-versions.js.map

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

@@ -3,6 +3,7 @@ import { GitHub } from '../github';
 import { VersioningStrategy } from '../versioning-strategy';
 import { Repository } from '../repository';
 import { ChangelogNotes, ChangelogSection } from '../changelog-notes';
+import { ExtraFile } from '../manifest';
 import { Update } from '../update';
 import { ConventionalCommit, Commit } from '../commit';
 import { Version, VersionsMap } from '../version';
@@ -37,7 +38,7 @@ export interface BaseStrategyOptions {
     changelogNotes?: ChangelogNotes;
     includeComponentInTag?: boolean;
     pullRequestTitlePattern?: string;
-    extraFiles?: string[];
+    extraFiles?: ExtraFile[];
 }
 /**
  * A strategy is responsible for determining which files are
@@ -57,7 +58,7 @@ export declare abstract class BaseStrategy implements Strategy {
     private releaseAs?;
     protected includeComponentInTag: boolean;
     private pullRequestTitlePattern?;
-    readonly extraFiles: string[];
+    readonly extraFiles: ExtraFile[];
     readonly changelogNotes: ChangelogNotes;
     protected changelogSections?: ChangelogSection[];
     constructor(options: BaseStrategyOptions);

package/build/src/strategies/base.js

@@ -26,6 +26,8 @@ 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 generic_json_1 = require("../updaters/generic-json");
+const generic_xml_1 = require("../updaters/generic-xml");
 const DEFAULT_CHANGELOG_PATH = 'CHANGELOG.md';
 /**
  * A strategy is responsible for determining which files are
@@ -163,12 +165,31 @@ class BaseStrategy {
         };
     }
     extraFileUpdates(version) {
-        const genericUpdater = new generic_1.Generic({ version });
-        return this.extraFiles.map(path => ({
-            path: this.addPath(path),
-            createIfMissing: false,
-            updater: genericUpdater,
-        }));
+        return this.extraFiles.map(extraFile => {
+            if (typeof extraFile === 'object') {
+                switch (extraFile.type) {
+                    case 'json':
+                        return {
+                            path: this.addPath(extraFile.path),
+                            createIfMissing: false,
+                            updater: new generic_json_1.GenericJson(extraFile.jsonpath, version),
+                        };
+                    case 'xml':
+                        return {
+                            path: this.addPath(extraFile.path),
+                            createIfMissing: false,
+                            updater: new generic_xml_1.GenericXml(extraFile.xpath, version),
+                        };
+                    default:
+                        throw new Error(`unsupported extraFile type: ${extraFile.type}`);
+                }
+            }
+            return {
+                path: this.addPath(extraFile),
+                createIfMissing: false,
+                updater: new generic_1.Generic({ version }),
+            };
+        });
     }
     changelogEmpty(changelogEntry) {
         return changelogEntry.split('\n').length <= 1;

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

@@ -198,9 +198,12 @@ class JavaYoshi extends base_1.BaseStrategy {
                 }),
             });
         });
-        this.extraFiles.forEach(path => {
+        this.extraFiles.forEach(extraFile => {
+            if (typeof extraFile === 'object') {
+                return;
+            }
             updates.push({
-                path,
+                path: extraFile,
                 createIfMissing: false,
                 updater: new java_update_1.JavaUpdate({
                     version,

package/build/src/strategies/ocaml.js

@@ -61,6 +61,16 @@ class OCaml extends base_1.BaseStrategy {
                 }),
             });
         });
+        const opamLockedPaths = await this.github.findFilesByExtension('opam.locked', this.path);
+        opamLockedPaths.filter(notEsyLock).forEach(path => {
+            updates.push({
+                path: this.addPath(path),
+                createIfMissing: false,
+                updater: new opam_1.Opam({
+                    version,
+                }),
+            });
+        });
         updates.push({
             path: this.addPath('dune-project'),
             createIfMissing: false,

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

@@ -0,0 +1,13 @@
+import { Updater } from '../update';
+import { Version } from '../version';
+export declare class GenericJson implements Updater {
+    readonly jsonpath: string;
+    readonly version: Version;
+    constructor(jsonpath: string, version: Version);
+    /**
+     * Given initial file contents, return updated contents.
+     * @param {string} content The initial content
+     * @returns {string} The updated content
+     */
+    updateContent(content: string): string;
+}

package/build/src/updaters/generic-json.js

@@ -0,0 +1,43 @@
+"use strict";
+// Copyright 2022 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.GenericJson = void 0;
+const jp = require("jsonpath");
+const json_stringify_1 = require("../util/json-stringify");
+const logger_1 = require("../util/logger");
+class GenericJson {
+    constructor(jsonpath, version) {
+        this.jsonpath = jsonpath;
+        this.version = version;
+    }
+    /**
+     * Given initial file contents, return updated contents.
+     * @param {string} content The initial content
+     * @returns {string} The updated content
+     */
+    updateContent(content) {
+        const data = JSON.parse(content);
+        const nodes = jp.apply(data, this.jsonpath, _val => {
+            return this.version.toString();
+        });
+        if (!nodes) {
+            logger_1.logger.warn(`No entries modified in ${this.jsonpath}`);
+            return content;
+        }
+        return json_stringify_1.jsonStringify(data, content);
+    }
+}
+exports.GenericJson = GenericJson;
+//# sourceMappingURL=generic-json.js.map

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

@@ -0,0 +1,13 @@
+import { Updater } from '../update';
+import { Version } from '../version';
+export declare class GenericXml implements Updater {
+    private xpath;
+    private version;
+    constructor(xpath: string, version: Version);
+    /**
+     * Given initial file contents, return updated contents.
+     * @param {string} content The initial content
+     * @returns {string} The updated content
+     */
+    updateContent(content: string): string;
+}

package/build/src/updaters/generic-xml.js

@@ -0,0 +1,47 @@
+"use strict";
+// Copyright 2022 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.GenericXml = void 0;
+const xpath = require("xpath");
+const dom = require("xmldom");
+class GenericXml {
+    constructor(xpath, version) {
+        this.xpath = xpath;
+        this.version = version;
+    }
+    /**
+     * Given initial file contents, return updated contents.
+     * @param {string} content The initial content
+     * @returns {string} The updated content
+     */
+    updateContent(content) {
+        const document = new dom.DOMParser().parseFromString(content);
+        const iterator = xpath.evaluate(this.xpath, document, null, 0, null);
+        let node;
+        let updated = false;
+        while ((node = iterator.iterateNext())) {
+            node.textContent = this.version.toString();
+            updated = true;
+        }
+        if (updated) {
+            return new dom.XMLSerializer().serializeToString(document);
+        }
+        else {
+            return content;
+        }
+    }
+}
+exports.GenericXml = GenericXml;
+//# sourceMappingURL=generic-xml.js.map

package/build/src/versioning-strategies/dependency-manifest.js

@@ -18,7 +18,7 @@ const version_1 = require("../version");
 const semver = require("semver");
 const default_1 = require("./default");
 const versioning_strategy_1 = require("../versioning-strategy");
-const DEPENDENCY_UPDATE_REGEX = /^deps: update dependency (.*) to (v.*)(\s\(#\d+\))?$/m;
+const DEPENDENCY_UPDATE_REGEX = /^deps: update dependency (.*) to (v[^\s]*)(\s\(#\d+\))?$/m;
 /**
  * This VersioningStrategy looks at `deps` type commits and tries to
  * mirror the semantic version bump for that dependency update. For

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "release-please",
-  "version": "13.4.14",
+  "version": "13.6.0",
   "description": "generate release PRs based on the conventionalcommits.org spec",
   "main": "./build/src/index.js",
   "bin": "./build/src/bin/release-please.js",
@@ -41,11 +41,13 @@
     "@types/chai": "^4.1.7",
     "@types/iarna__toml": "^2.0.1",
     "@types/js-yaml": "^4.0.0",
+    "@types/jsonpath": "^0.2.0",
     "@types/mocha": "^9.0.0",
     "@types/node": "^16.0.0",
     "@types/pino": "^7.0.0",
     "@types/semver": "^7.0.0",
     "@types/sinon": "^10.0.0",
+    "@types/xmldom": "^0.1.31",
     "@types/yargs": "^17.0.0",
     "c8": "^7.0.0",
     "chai": "^4.2.0",
@@ -76,6 +78,7 @@
     "detect-indent": "^6.1.0",
     "figures": "^3.0.0",
     "js-yaml": "^4.0.0",
+    "jsonpath": "^1.1.1",
     "node-html-parser": "^5.0.0",
     "parse-github-repo-url": "^1.4.1",
     "semver": "^7.0.0",
@@ -83,6 +86,8 @@
     "typescript": "^3.8.3",
     "unist-util-visit": "^2.0.3",
     "unist-util-visit-parents": "^3.1.1",
+    "xmldom": "^0.6.0",
+    "xpath": "^0.0.32",
     "yargs": "^17.0.0"
   },
   "engines": {