release-please 13.10.1 → 13.11.1

package/CHANGELOG.md

@@ -4,6 +4,29 @@
 
 [1]: https://www.npmjs.com/package/release-please?activeTab=versions
 
+### [13.11.1](https://github.com/googleapis/release-please/compare/v13.11.0...v13.11.1) (2022-04-15)
+
+
+### Bug Fixes
+
+* **deps:** switch from `xmldom` to `@xmldom/xmldom` and update to v0.8.2 ([#1393](https://github.com/googleapis/release-please/issues/1393)) ([b6af677](https://github.com/googleapis/release-please/commit/b6af677da635493230d7e3a632aeedb5cfd1edb7))
+
+## [13.11.0](https://github.com/googleapis/release-please/compare/v13.10.2...v13.11.0) (2022-04-15)
+
+
+### Features
+
+* **cli:** show file diff for release-pr command with --dry-run and --trace ([fa2cc34](https://github.com/googleapis/release-please/commit/fa2cc343c327864a98ab896ddc92ced89db9ae73))
+* introduce extensible factories ([#1342](https://github.com/googleapis/release-please/issues/1342)) ([b54e90e](https://github.com/googleapis/release-please/commit/b54e90e09751945914feb987508561c39f27cbe3))
+
+### [13.10.2](https://github.com/googleapis/release-please/compare/v13.10.1...v13.10.2) (2022-04-14)
+
+
+### Bug Fixes
+
+* **java:** snapshots should bump versionsMap versions ([#1386](https://github.com/googleapis/release-please/issues/1386)) ([558331c](https://github.com/googleapis/release-please/commit/558331c160a066daeda476438f6524bf958f8d41)), closes [#1381](https://github.com/googleapis/release-please/issues/1381)
+* **ruby-yoshi:** Remove bolded scope and fix link removal ([#1382](https://github.com/googleapis/release-please/issues/1382)) ([f6b3202](https://github.com/googleapis/release-please/commit/f6b32024998c4e414b723a4071166f253e95b1d2))
+
 ### [13.10.1](https://github.com/googleapis/release-please/compare/v13.10.0...v13.10.1) (2022-04-13)
 
 

package/build/src/bin/release-please.d.ts

@@ -10,6 +10,7 @@ interface ErrorObject {
 }
 interface GitHubArgs {
     dryRun?: boolean;
+    trace?: boolean;
     repoUrl?: string;
     token?: string;
     apiUrl?: string;
@@ -60,9 +61,9 @@ interface PullRequestStrategyArgs {
 interface BootstrapArgs extends GitHubArgs, ManifestArgs, ManifestConfigArgs, VersioningArgs, PullRequestArgs, PullRequestStrategyArgs, ReleaseArgs {
     initialVersion?: string;
 }
-export declare const parser: yargs.Argv<BootstrapArgs & {
+export declare const parser: yargs.Argv<yargs.Omit<BootstrapArgs & {
     debug: boolean;
-} & {
+}, "trace"> & {
     trace: boolean;
 }>;
 interface HandleError {

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

@@ -23,6 +23,7 @@ const changelog_notes_1 = require("../changelog-notes");
 const logger_1 = require("../util/logger");
 const factory_1 = require("../factory");
 const bootstrapper_1 = require("../bootstrapper");
+const diff_1 = require("diff");
 // eslint-disable-next-line @typescript-eslint/no-var-requires
 const parseGithubRepoUrl = require('parse-github-repo-url');
 function gitHubOptions(yargs) {
@@ -302,10 +303,21 @@ const createReleasePullRequestCommand = {
                 console.log('draft:', pullRequest.draft);
                 console.log('body:', pullRequest.body.toString());
                 console.log('updates:', pullRequest.updates.length);
+                const changes = await github.buildChangeSet(pullRequest.updates, targetBranch);
                 for (const update of pullRequest.updates) {
                     console.log(`  ${update.path}: `, 
                     // eslint-disable-next-line @typescript-eslint/no-explicit-any
                     update.updater.constructor);
+                    if (argv.trace) {
+                        const change = changes.get(update.path);
+                        if (change) {
+                            const patch = diff_1.createPatch(update.path, change.originalContent || '', change.content || '');
+                            console.log(patch);
+                        }
+                        else {
+                            console.warn(`no change found for ${update.path}`);
+                        }
+                    }
                 }
             }
         }

package/build/src/factories/changelog-notes-factory.d.ts

@@ -0,0 +1,16 @@
+import { GitHub } from '../github';
+import { ChangelogNotes, ChangelogSection } from '../changelog-notes';
+export declare type ChangelogNotesType = string;
+export interface ChangelogNotesFactoryOptions {
+    type: ChangelogNotesType;
+    github: GitHub;
+    changelogSections?: ChangelogSection[];
+    commitPartial?: string;
+    headerPartial?: string;
+    mainTemplate?: string;
+}
+export declare type ChangelogNotesBuilder = (options: ChangelogNotesFactoryOptions) => ChangelogNotes;
+export declare function buildChangelogNotes(options: ChangelogNotesFactoryOptions): ChangelogNotes;
+export declare function registerChangelogNotes(name: string, changelogNotesBuilder: ChangelogNotesBuilder): void;
+export declare function unregisterChangelogNotes(name: string): void;
+export declare function getChangelogTypes(): readonly ChangelogNotesType[];

package/build/src/factories/changelog-notes-factory.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.getChangelogTypes = exports.unregisterChangelogNotes = exports.registerChangelogNotes = exports.buildChangelogNotes = void 0;
+const github_1 = require("../changelog-notes/github");
+const default_1 = require("../changelog-notes/default");
+const changelogNotesFactories = {
+    github: options => new github_1.GitHubChangelogNotes(options.github),
+    default: options => new default_1.DefaultChangelogNotes(options),
+};
+function buildChangelogNotes(options) {
+    const builder = changelogNotesFactories[options.type];
+    if (builder) {
+        return builder(options);
+    }
+    throw new Error(`Unknown changelog type: ${options.type}`);
+}
+exports.buildChangelogNotes = buildChangelogNotes;
+function registerChangelogNotes(name, changelogNotesBuilder) {
+    changelogNotesFactories[name] = changelogNotesBuilder;
+}
+exports.registerChangelogNotes = registerChangelogNotes;
+function unregisterChangelogNotes(name) {
+    delete changelogNotesFactories[name];
+}
+exports.unregisterChangelogNotes = unregisterChangelogNotes;
+function getChangelogTypes() {
+    return Object.keys(changelogNotesFactories).sort();
+}
+exports.getChangelogTypes = getChangelogTypes;
+//# sourceMappingURL=changelog-notes-factory.js.map

package/build/src/factories/plugin-factory.d.ts

@@ -0,0 +1,17 @@
+import { PluginType, RepositoryConfig } from '../manifest';
+import { GitHub } from '../github';
+import { ManifestPlugin } from '../plugin';
+import { VersioningStrategyType } from './versioning-strategy-factory';
+export interface PluginFactoryOptions {
+    type: PluginType;
+    github: GitHub;
+    targetBranch: string;
+    repositoryConfig: RepositoryConfig;
+    alwaysLinkLocal?: boolean;
+    updateAllPackages?: boolean;
+}
+export declare type PluginBuilder = (options: PluginFactoryOptions) => ManifestPlugin;
+export declare function buildPlugin(options: PluginFactoryOptions): ManifestPlugin;
+export declare function registerPlugin(name: string, pluginBuilder: PluginBuilder): void;
+export declare function unregisterPlugin(name: string): void;
+export declare function getPluginTypes(): readonly VersioningStrategyType[];

package/build/src/factories/plugin-factory.js

@@ -0,0 +1,54 @@
+"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.getPluginTypes = exports.unregisterPlugin = exports.registerPlugin = exports.buildPlugin = void 0;
+const linked_versions_1 = require("../plugins/linked-versions");
+const cargo_workspace_1 = require("../plugins/cargo-workspace");
+const node_workspace_1 = require("../plugins/node-workspace");
+const pluginFactories = {
+    'linked-versions': options => new linked_versions_1.LinkedVersions(options.github, options.targetBranch, options.repositoryConfig, options.type.groupName, options.type.components),
+    'cargo-workspace': options => new cargo_workspace_1.CargoWorkspace(options.github, options.targetBranch, options.repositoryConfig, options),
+    'node-workspace': options => new node_workspace_1.NodeWorkspace(options.github, options.targetBranch, options.repositoryConfig, options),
+};
+function buildPlugin(options) {
+    if (typeof options.type === 'object') {
+        const builder = pluginFactories[options.type.type];
+        if (builder) {
+            return builder(options);
+        }
+        throw new Error(`Unknown plugin type: ${options.type.type}`);
+    }
+    else {
+        const builder = pluginFactories[options.type];
+        if (builder) {
+            return builder(options);
+        }
+        throw new Error(`Unknown plugin type: ${options.type}`);
+    }
+}
+exports.buildPlugin = buildPlugin;
+function registerPlugin(name, pluginBuilder) {
+    pluginFactories[name] = pluginBuilder;
+}
+exports.registerPlugin = registerPlugin;
+function unregisterPlugin(name) {
+    delete pluginFactories[name];
+}
+exports.unregisterPlugin = unregisterPlugin;
+function getPluginTypes() {
+    return Object.keys(pluginFactories).sort();
+}
+exports.getPluginTypes = getPluginTypes;
+//# sourceMappingURL=plugin-factory.js.map

package/build/src/factories/versioning-strategy-factory.d.ts

@@ -0,0 +1,12 @@
+import { VersioningStrategy } from '../versioning-strategy';
+export declare type VersioningStrategyType = string;
+export interface VersioningStrategyFactoryOptions {
+    type?: VersioningStrategyType;
+    bumpMinorPreMajor?: boolean;
+    bumpPatchForMinorPreMajor?: boolean;
+}
+export declare type VersioningStrategyBuilder = (options: VersioningStrategyFactoryOptions) => VersioningStrategy;
+export declare function buildVersioningStrategy(options: VersioningStrategyFactoryOptions): VersioningStrategy;
+export declare function registerVersioningStrategy(name: string, versioningStrategyBuilder: VersioningStrategyBuilder): void;
+export declare function unregisterVersioningStrategy(name: string): void;
+export declare function getVersioningStrategyTypes(): readonly VersioningStrategyType[];

package/build/src/factories/versioning-strategy-factory.js

@@ -0,0 +1,45 @@
+"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.getVersioningStrategyTypes = exports.unregisterVersioningStrategy = exports.registerVersioningStrategy = exports.buildVersioningStrategy = void 0;
+const default_1 = require("../versioning-strategies/default");
+const always_bump_patch_1 = require("../versioning-strategies/always-bump-patch");
+const service_pack_1 = require("../versioning-strategies/service-pack");
+const versioningTypes = {
+    default: options => new default_1.DefaultVersioningStrategy(options),
+    'always-bump-patch': options => new always_bump_patch_1.AlwaysBumpPatch(options),
+    'service-pack': options => new service_pack_1.ServicePackVersioningStrategy(options),
+};
+function buildVersioningStrategy(options) {
+    const builder = versioningTypes[options.type || 'default'];
+    if (builder) {
+        return builder(options);
+    }
+    throw new Error(`Unknown versioning strategy type: ${options.type}`);
+}
+exports.buildVersioningStrategy = buildVersioningStrategy;
+function registerVersioningStrategy(name, versioningStrategyBuilder) {
+    versioningTypes[name] = versioningStrategyBuilder;
+}
+exports.registerVersioningStrategy = registerVersioningStrategy;
+function unregisterVersioningStrategy(name) {
+    delete versioningTypes[name];
+}
+exports.unregisterVersioningStrategy = unregisterVersioningStrategy;
+function getVersioningStrategyTypes() {
+    return Object.keys(versioningTypes).sort();
+}
+exports.getVersioningStrategyTypes = getVersioningStrategyTypes;
+//# sourceMappingURL=versioning-strategy-factory.js.map

package/build/src/factory.d.ts

@@ -1,39 +1,18 @@
 import { Strategy } from './strategy';
 import { GitHub } from './github';
-import { ReleaserConfig, PluginType, RepositoryConfig } from './manifest';
-import { ManifestPlugin } from './plugin';
-import { ChangelogNotes, ChangelogSection } from './changelog-notes';
-declare const allReleaseTypes: readonly ["dart", "dotnet-yoshi", "elixir", "go", "go-yoshi", "helm", "java", "java-backport", "java-bom", "java-lts", "java-yoshi", "krm-blueprint", "maven", "node", "ocaml", "php", "php-yoshi", "python", "ruby", "ruby-yoshi", "rust", "simple", "terraform-module"];
-export declare type ReleaseType = typeof allReleaseTypes[number];
-export declare function getReleaserTypes(): readonly ReleaseType[];
-export declare function getVersioningStrategyTypes(): readonly VersioningStrategyType[];
-export declare function getChangelogTypes(): readonly ChangelogNotesType[];
+import { ReleaserConfig } from './manifest';
+import { BaseStrategyOptions } from './strategies/base';
+export * from './factories/changelog-notes-factory';
+export * from './factories/plugin-factory';
+export * from './factories/versioning-strategy-factory';
+export declare type ReleaseType = string;
+export declare type ReleaseBuilder = (options: BaseStrategyOptions) => Strategy;
 export interface StrategyFactoryOptions extends ReleaserConfig {
     github: GitHub;
     path?: string;
     targetBranch?: string;
 }
 export declare function buildStrategy(options: StrategyFactoryOptions): Promise<Strategy>;
-declare const allVersioningTypes: readonly ["default", "always-bump-patch", "service-pack"];
-export declare type VersioningStrategyType = typeof allVersioningTypes[number];
-interface PluginFactoryOptions {
-    type: PluginType;
-    github: GitHub;
-    targetBranch: string;
-    repositoryConfig: RepositoryConfig;
-    alwaysLinkLocal?: boolean;
-    updateAllPackages?: boolean;
-}
-export declare function buildPlugin(options: PluginFactoryOptions): ManifestPlugin;
-declare const allChangelogNotesTypes: readonly ["default", "github"];
-export declare type ChangelogNotesType = typeof allChangelogNotesTypes[number];
-interface ChangelogNotesFactoryOptions {
-    type: ChangelogNotesType;
-    github: GitHub;
-    changelogSections?: ChangelogSection[];
-    commitPartial?: string;
-    headerPartial?: string;
-    mainTemplate?: string;
-}
-export declare function buildChangelogNotes(options: ChangelogNotesFactoryOptions): ChangelogNotes;
-export {};
+export declare function registerReleaseType(name: string, strategyBuilder: ReleaseBuilder): void;
+export declare function unregisterReleaseType(name: string): void;
+export declare function getReleaserTypes(): readonly ReleaseType[];

package/build/src/factory.js

@@ -12,8 +12,18 @@
 // 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.
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !exports.hasOwnProperty(p)) __createBinding(exports, m, p);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.buildChangelogNotes = exports.buildPlugin = exports.buildStrategy = exports.getChangelogTypes = exports.getVersioningStrategyTypes = exports.getReleaserTypes = void 0;
+exports.getReleaserTypes = exports.unregisterReleaseType = exports.registerReleaseType = exports.buildStrategy = void 0;
 const go_1 = require("./strategies/go");
 const go_yoshi_1 = require("./strategies/go-yoshi");
 const java_yoshi_1 = require("./strategies/java-yoshi");
@@ -31,219 +41,91 @@ const helm_1 = require("./strategies/helm");
 const elixir_1 = require("./strategies/elixir");
 const dart_1 = require("./strategies/dart");
 const node_1 = require("./strategies/node");
-const default_1 = require("./versioning-strategies/default");
 const always_bump_patch_1 = require("./versioning-strategies/always-bump-patch");
 const service_pack_1 = require("./versioning-strategies/service-pack");
 const dependency_manifest_1 = require("./versioning-strategies/dependency-manifest");
-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");
 const dotnet_yoshi_1 = require("./strategies/dotnet-yoshi");
 const java_1 = require("./strategies/java");
 const maven_1 = require("./strategies/maven");
-// 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`
-// object below.
-const allReleaseTypes = [
-    'dart',
-    'dotnet-yoshi',
-    'elixir',
-    'go',
-    'go-yoshi',
-    'helm',
-    'java',
-    'java-backport',
-    'java-bom',
-    'java-lts',
-    'java-yoshi',
-    'krm-blueprint',
-    'maven',
-    'node',
-    'ocaml',
-    'php',
-    'php-yoshi',
-    'python',
-    'ruby',
-    'ruby-yoshi',
-    'rust',
-    'simple',
-    'terraform-module',
-];
+const versioning_strategy_factory_1 = require("./factories/versioning-strategy-factory");
+const changelog_notes_factory_1 = require("./factories/changelog-notes-factory");
+__exportStar(require("./factories/changelog-notes-factory"), exports);
+__exportStar(require("./factories/plugin-factory"), exports);
+__exportStar(require("./factories/versioning-strategy-factory"), exports);
 const releasers = {
     'dotnet-yoshi': options => new dotnet_yoshi_1.DotnetYoshi(options),
     go: options => new go_1.Go(options),
     'go-yoshi': options => new go_yoshi_1.GoYoshi(options),
+    java: options => new java_1.Java(options),
+    maven: options => new maven_1.Maven(options),
+    'java-yoshi': options => new java_yoshi_1.JavaYoshi(options),
+    'java-backport': options => new java_yoshi_1.JavaYoshi({
+        ...options,
+        versioningStrategy: new always_bump_patch_1.AlwaysBumpPatch(),
+    }),
+    'java-bom': options => new java_yoshi_1.JavaYoshi({
+        ...options,
+        versioningStrategy: new dependency_manifest_1.DependencyManifest({
+            bumpMinorPreMajor: options.bumpMinorPreMajor,
+            bumpPatchForMinorPreMajor: options.bumpPatchForMinorPreMajor,
+        }),
+    }),
+    'java-lts': options => new java_yoshi_1.JavaYoshi({
+        ...options,
+        versioningStrategy: new service_pack_1.ServicePackVersioningStrategy(),
+    }),
     'krm-blueprint': options => new krm_blueprint_1.KRMBlueprint(options),
     node: options => new node_1.Node(options),
     ocaml: options => new ocaml_1.OCaml(options),
     php: options => new php_1.PHP(options),
     'php-yoshi': options => new php_yoshi_1.PHPYoshi(options),
     python: options => new python_1.Python(options),
+    ruby: options => new ruby_1.Ruby(options),
+    'ruby-yoshi': options => new ruby_yoshi_1.RubyYoshi(options),
     rust: options => new rust_1.Rust(options),
+    simple: options => new simple_1.Simple(options),
     'terraform-module': options => new terraform_module_1.TerraformModule(options),
     helm: options => new helm_1.Helm(options),
     elixir: options => new elixir_1.Elixir(options),
     dart: options => new dart_1.Dart(options),
 };
-function getReleaserTypes() {
-    return allReleaseTypes;
-}
-exports.getReleaserTypes = getReleaserTypes;
-function getVersioningStrategyTypes() {
-    return allVersioningTypes;
-}
-exports.getVersioningStrategyTypes = getVersioningStrategyTypes;
-function getChangelogTypes() {
-    return allChangelogNotesTypes;
-}
-exports.getChangelogTypes = getChangelogTypes;
 async function buildStrategy(options) {
     var _a;
     const targetBranch = (_a = options.targetBranch) !== null && _a !== void 0 ? _a : options.github.repository.defaultBranch;
-    const versioningStrategy = buildVersioningStrategy({
+    const versioningStrategy = versioning_strategy_factory_1.buildVersioningStrategy({
         type: options.versioning,
         bumpMinorPreMajor: options.bumpMinorPreMajor,
         bumpPatchForMinorPreMajor: options.bumpPatchForMinorPreMajor,
     });
-    const changelogNotes = buildChangelogNotes({
+    const changelogNotes = changelog_notes_factory_1.buildChangelogNotes({
         type: options.changelogType || 'default',
         github: options.github,
         changelogSections: options.changelogSections,
     });
     const strategyOptions = {
-        github: options.github,
+        skipGitHubRelease: options.skipGithubRelease,
+        ...options,
         targetBranch,
-        path: options.path,
-        bumpMinorPreMajor: options.bumpMinorPreMajor,
-        bumpPatchForMinorPreMajor: options.bumpPatchForMinorPreMajor,
-        component: options.component,
-        packageName: options.packageName,
-        changelogPath: options.changelogPath,
-        changelogSections: options.changelogSections,
         versioningStrategy,
-        skipGitHubRelease: options.skipGithubRelease,
-        releaseAs: options.releaseAs,
-        includeComponentInTag: options.includeComponentInTag,
         changelogNotes,
-        pullRequestTitlePattern: options.pullRequestTitlePattern,
-        extraFiles: options.extraFiles,
-        tagSeparator: options.tagSeparator,
     };
-    switch (options.releaseType) {
-        case 'ruby': {
-            return new ruby_1.Ruby({
-                ...strategyOptions,
-                versionFile: options.versionFile,
-            });
-        }
-        case 'ruby-yoshi': {
-            return new ruby_yoshi_1.RubyYoshi({
-                ...strategyOptions,
-                versionFile: options.versionFile,
-            });
-        }
-        case 'java': {
-            return new java_1.Java({
-                ...strategyOptions,
-                snapshotLabels: options.snapshotLabels,
-            });
-        }
-        case 'maven': {
-            return new maven_1.Maven({
-                ...strategyOptions,
-                snapshotLabels: options.snapshotLabels,
-            });
-        }
-        case 'java-yoshi': {
-            return new java_yoshi_1.JavaYoshi({
-                ...strategyOptions,
-                snapshotLabels: options.snapshotLabels,
-            });
-        }
-        case 'java-backport': {
-            return new java_yoshi_1.JavaYoshi({
-                ...strategyOptions,
-                versioningStrategy: new always_bump_patch_1.AlwaysBumpPatch(),
-            });
-        }
-        case 'java-bom': {
-            return new java_yoshi_1.JavaYoshi({
-                ...strategyOptions,
-                versioningStrategy: new dependency_manifest_1.DependencyManifest({
-                    bumpMinorPreMajor: options.bumpMinorPreMajor,
-                    bumpPatchForMinorPreMajor: options.bumpPatchForMinorPreMajor,
-                }),
-            });
-        }
-        case 'java-lts': {
-            return new java_yoshi_1.JavaYoshi({
-                ...strategyOptions,
-                versioningStrategy: new service_pack_1.ServicePackVersioningStrategy(),
-            });
-        }
-        case 'simple': {
-            return new simple_1.Simple({
-                ...strategyOptions,
-                versionFile: options.versionFile,
-            });
-        }
-        default: {
-            const builder = releasers[options.releaseType];
-            if (builder) {
-                return builder(strategyOptions);
-            }
-            throw new Error(`Unknown release type: ${options.releaseType}`);
-        }
+    const builder = releasers[options.releaseType];
+    if (builder) {
+        return builder(strategyOptions);
     }
+    throw new Error(`Unknown release type: ${options.releaseType}`);
 }
 exports.buildStrategy = buildStrategy;
-const allVersioningTypes = [
-    'default',
-    'always-bump-patch',
-    'service-pack',
-];
-function buildVersioningStrategy(options) {
-    switch (options.type) {
-        case 'always-bump-patch':
-            return new always_bump_patch_1.AlwaysBumpPatch(options);
-        case 'service-pack':
-            return new service_pack_1.ServicePackVersioningStrategy(options);
-        default:
-            return new default_1.DefaultVersioningStrategy(options);
-    }
+function registerReleaseType(name, strategyBuilder) {
+    releasers[name] = strategyBuilder;
 }
-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);
-        case 'node-workspace':
-            return new node_workspace_1.NodeWorkspace(options.github, options.targetBranch, options.repositoryConfig, options);
-        default:
-            throw new Error(`Unknown plugin type: ${options.type}`);
-    }
+exports.registerReleaseType = registerReleaseType;
+function unregisterReleaseType(name) {
+    delete releasers[name];
 }
-exports.buildPlugin = buildPlugin;
-const allChangelogNotesTypes = ['default', 'github'];
-function buildChangelogNotes(options) {
-    switch (options.type) {
-        case 'github':
-            return new github_1.GitHubChangelogNotes(options.github);
-        case 'default':
-            return new default_2.DefaultChangelogNotes(options);
-        default:
-            throw new Error(`Unknown changelog type: ${options.type}`);
-    }
+exports.unregisterReleaseType = unregisterReleaseType;
+function getReleaserTypes() {
+    return Object.keys(releasers).sort();
 }
-exports.buildChangelogNotes = buildChangelogNotes;
+exports.getReleaserTypes = getReleaserTypes;
 //# sourceMappingURL=factory.js.map

package/build/src/github.d.ts

@@ -59,6 +59,12 @@ export interface GitHubTag {
     name: string;
     sha: string;
 }
+interface FileDiff {
+    readonly mode: '100644' | '100755' | '040000' | '160000' | '120000';
+    readonly content: string | null;
+    readonly originalContent: string | null;
+}
+export declare type ChangeSet = Map<string, FileDiff>;
 export declare class GitHub {
     readonly repository: Repository;
     private octokit;
@@ -256,7 +262,7 @@ export declare class GitHub {
      * @return {Changes} The changeset to suggest.
      * @throws {GitHubAPIError} on an API error
      */
-    private getChangeSet;
+    buildChangeSet(updates: Update[], defaultBranch: string): Promise<ChangeSet>;
     /**
      * Returns a list of paths to all files with a given file
      * extension.

package/build/src/github.js

@@ -127,7 +127,7 @@ class GitHub {
         });
         this.createPullRequest = wrapAsync(async (pullRequest, targetBranch, message, updates, options) => {
             //  Update the files for the release if not already supplied
-            const changes = await this.getChangeSet(updates, targetBranch);
+            const changes = await this.buildChangeSet(updates, targetBranch);
             const prNumber = await code_suggester_1.createPullRequest(this.octokit, changes, {
                 upstreamOwner: this.repository.owner,
                 upstreamRepo: this.repository.repo,
@@ -175,7 +175,7 @@ class GitHub {
          */
         this.updatePullRequest = wrapAsync(async (number, releasePullRequest, targetBranch, options) => {
             //  Update the files for the release if not already supplied
-            const changes = await this.getChangeSet(releasePullRequest.updates, targetBranch);
+            const changes = await this.buildChangeSet(releasePullRequest.updates, targetBranch);
             let message = releasePullRequest.title.toString();
             if (options === null || options === void 0 ? void 0 : options.signoffUser) {
                 message = signoff_commit_message_1.signoffCommitMessage(message, options.signoffUser);
@@ -891,7 +891,7 @@ class GitHub {
      * @return {Changes} The changeset to suggest.
      * @throws {GitHubAPIError} on an API error
      */
-    async getChangeSet(updates, defaultBranch) {
+    async buildChangeSet(updates, defaultBranch) {
         const changes = new Map();
         for (const update of updates) {
             let content;
@@ -915,6 +915,7 @@ class GitHub {
             if (updatedContent) {
                 changes.set(update.path, {
                     content: updatedContent,
+                    originalContent: (content === null || content === void 0 ? void 0 : content.parsedContent) || null,
                     mode: (content === null || content === void 0 ? void 0 : content.mode) || file_cache_1.DEFAULT_FILE_MODE,
                 });
             }

package/build/src/index.d.ts

@@ -1,5 +1,11 @@
 export * as Errors from './errors';
-export { Manifest, ReleaserConfig, ManifestOptions } from './manifest';
-export { ReleaseType, getReleaserTypes, VersioningStrategyType, getVersioningStrategyTypes, ChangelogNotesType, getChangelogTypes, } from './factory';
+export { Manifest, ReleaserConfig, ManifestOptions, PluginType, } from './manifest';
+export { Commit, ConventionalCommit } from './commit';
+export { BaseStrategyOptions, BuildUpdatesOptions } from './strategies/base';
+export { ReleaseBuilder, ReleaseType, getReleaserTypes, registerReleaseType, } from './factory';
+export { ChangelogNotesBuilder, ChangelogNotesFactoryOptions, ChangelogNotesType, getChangelogTypes, registerChangelogNotes, } from './factories/changelog-notes-factory';
+export { PluginBuilder, PluginFactoryOptions, getPluginTypes, registerPlugin, } from './factories/plugin-factory';
+export { VersioningStrategyBuilder, VersioningStrategyFactoryOptions, VersioningStrategyType, getVersioningStrategyTypes, registerVersioningStrategy, } from './factories/versioning-strategy-factory';
+export { BuildNotesOptions, ChangelogNotes, ChangelogSection, } from './changelog-notes';
 export { Logger, setLogger } from './util/logger';
 export { GitHub } from './github';

package/build/src/index.js

@@ -18,8 +18,16 @@ 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; } });
+Object.defineProperty(exports, "registerReleaseType", { enumerable: true, get: function () { return factory_1.registerReleaseType; } });
+var changelog_notes_factory_1 = require("./factories/changelog-notes-factory");
+Object.defineProperty(exports, "getChangelogTypes", { enumerable: true, get: function () { return changelog_notes_factory_1.getChangelogTypes; } });
+Object.defineProperty(exports, "registerChangelogNotes", { enumerable: true, get: function () { return changelog_notes_factory_1.registerChangelogNotes; } });
+var plugin_factory_1 = require("./factories/plugin-factory");
+Object.defineProperty(exports, "getPluginTypes", { enumerable: true, get: function () { return plugin_factory_1.getPluginTypes; } });
+Object.defineProperty(exports, "registerPlugin", { enumerable: true, get: function () { return plugin_factory_1.registerPlugin; } });
+var versioning_strategy_factory_1 = require("./factories/versioning-strategy-factory");
+Object.defineProperty(exports, "getVersioningStrategyTypes", { enumerable: true, get: function () { return versioning_strategy_factory_1.getVersioningStrategyTypes; } });
+Object.defineProperty(exports, "registerVersioningStrategy", { enumerable: true, get: function () { return versioning_strategy_factory_1.registerVersioningStrategy; } });
 var logger_1 = require("./util/logger");
 Object.defineProperty(exports, "setLogger", { enumerable: true, get: function () { return logger_1.setLogger; } });
 var github_1 = require("./github");

package/build/src/manifest.d.ts

@@ -74,8 +74,8 @@ interface ReleaserConfigJson {
     'changelog-type'?: ChangelogNotesType;
     'pull-request-title-pattern'?: string;
     'tag-separator'?: string;
-    'version-file'?: string;
     'extra-files'?: string[];
+    'version-file'?: string;
     'snapshot-label'?: string;
 }
 export interface ManifestOptions {
@@ -100,13 +100,16 @@ interface ReleaserPackageConfig extends ReleaserConfigJson {
     component?: string;
     'changelog-path'?: string;
 }
-declare type DirectPluginType = 'node-workspace' | 'cargo-workspace';
-interface LinkedVersionPluginConfig {
+export declare type DirectPluginType = string;
+export interface ConfigurablePluginType {
+    type: string;
+}
+export interface LinkedVersionPluginConfig extends ConfigurablePluginType {
     type: 'linked-versions';
     groupName: string;
     components: string[];
 }
-export declare type PluginType = DirectPluginType | LinkedVersionPluginConfig;
+export declare type PluginType = DirectPluginType | ConfigurablePluginType | LinkedVersionPluginConfig;
 /**
  * This is the schema of the manifest config json
  */

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

@@ -40,6 +40,8 @@ export interface BaseStrategyOptions {
     includeVInTag?: boolean;
     pullRequestTitlePattern?: string;
     extraFiles?: ExtraFile[];
+    versionFile?: string;
+    snapshotLabels?: string[];
 }
 /**
  * A strategy is responsible for determining which files are

package/build/src/strategies/base.js

@@ -204,14 +204,8 @@ class BaseStrategy {
         return changelogEntry.split('\n').length <= 1;
     }
     async updateVersionsMap(versionsMap, conventionalCommits, _newVersion) {
-        for (const versionKey of versionsMap.keys()) {
-            const version = versionsMap.get(versionKey);
-            if (!version) {
-                logger_1.logger.warn(`didn't find version for ${versionKey}`);
-                continue;
-            }
-            const newVersion = await this.versioningStrategy.bump(version, conventionalCommits);
-            versionsMap.set(versionKey, newVersion);
+        for (const [component, version] of versionsMap.entries()) {
+            versionsMap.set(component, await this.versioningStrategy.bump(version, conventionalCommits));
         }
         return versionsMap;
     }

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

@@ -5,9 +5,6 @@ import { Commit } from '../commit';
 import { Release } from '../release';
 import { ReleasePullRequest } from '../release-pull-request';
 import { VersioningStrategy } from '../versioning-strategy';
-export interface JavaStrategyOptions extends BaseStrategyOptions {
-    snapshotLabels?: string[];
-}
 export interface JavaBuildUpdatesOption extends BuildUpdatesOptions {
     isSnapshot?: boolean;
 }
@@ -19,7 +16,7 @@ export interface JavaBuildUpdatesOption extends BuildUpdatesOptions {
 export declare class Java extends BaseStrategy {
     protected readonly snapshotVersioning: VersioningStrategy;
     protected readonly snapshotLabels: string[];
-    constructor(options: JavaStrategyOptions);
+    constructor(options: BaseStrategyOptions);
     buildReleasePullRequest(commits: Commit[], latestRelease?: Release, draft?: boolean, labels?: string[]): Promise<ReleasePullRequest | undefined>;
     protected buildSnapshotPullRequest(latestRelease?: Release, draft?: boolean, labels?: string[]): Promise<ReleasePullRequest>;
     isPublishedVersion(version: Version): boolean;

package/build/src/strategies/java.js

@@ -70,6 +70,9 @@ class Java extends base_1.BaseStrategy {
             ? await this.snapshotVersioning.bump(latestRelease.tag.version, [])
             : this.initialReleaseVersion();
         const versionsMap = await this.buildVersionsMap([]);
+        for (const [component, version] of versionsMap.entries()) {
+            versionsMap.set(component, await this.snapshotVersioning.bump(version, []));
+        }
         const pullRequestTitle = pull_request_title_1.PullRequestTitle.ofComponentTargetBranchVersion(component || '', this.targetBranch, newVersion);
         const branchName = component
             ? branch_name_1.BranchName.ofComponentTargetBranch(component, this.targetBranch)

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

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

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

@@ -82,8 +82,10 @@ class RubyYoshi extends base_1.BaseStrategy {
         return (releaseNotes
             // Remove links in version title line and standardize on h3
             .replace(/^###? \[([\d.]+)\]\([^)]*\)/gm, '### $1')
+            // Remove bolded scope from change lines
+            .replace(/^\* \*\*[\w-]+:\*\* /gm, '* ')
             // Remove PR and commit links from pull request title suffixes
-            .replace(/ \(\[#\d+\]\([^)]*\)\)( \(\[\w+\]\([^)]*\)\))?\s*$/gm, '')
+            .replace(/( \(\[(\w+|#\d+)\]\(https:\/\/github\.com\/[^)]*\)\))+\s*$/gm, '')
             // Standardize on h4 for change type subheaders
             .replace(/^### (Features|Bug Fixes|Documentation)$/gm, '#### $1')
             // Collapse 2 or more blank lines

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

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

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

@@ -1,11 +1,7 @@
 import { BaseStrategy, BuildUpdatesOptions, BaseStrategyOptions } from './base';
 import { Update } from '../update';
-interface SimpleStrategyOptions extends BaseStrategyOptions {
-    versionFile?: string;
-}
 export declare class Simple extends BaseStrategy {
     readonly versionFile: string;
-    constructor(options: SimpleStrategyOptions);
+    constructor(options: BaseStrategyOptions);
     protected buildUpdates(options: BuildUpdatesOptions): Promise<Update[]>;
 }
-export {};

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

@@ -14,7 +14,7 @@
 // limitations under the License.
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BaseXml = void 0;
-const dom = require("xmldom");
+const dom = require("@xmldom/xmldom");
 /**
  * Base class for all updaters working with XML files.
  */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "release-please",
-  "version": "13.10.1",
+  "version": "13.11.1",
   "description": "generate release PRs based on the conventionalcommits.org spec",
   "main": "./build/src/index.js",
   "bin": "./build/src/bin/release-please.js",
@@ -39,6 +39,7 @@
   "devDependencies": {
     "@octokit/types": "^6.1.0",
     "@types/chai": "^4.1.7",
+    "@types/diff": "^5.0.2",
     "@types/iarna__toml": "^2.0.1",
     "@types/js-yaml": "^4.0.0",
     "@types/jsonpath": "^0.2.0",
@@ -59,7 +60,7 @@
     "gts": "^3.0.0",
     "mocha": "^9.0.0",
     "nock": "^13.0.0",
-    "sinon": "13.0.1",
+    "sinon": "13.0.2",
     "snap-shot-it": "^7.0.0"
   },
   "dependencies": {
@@ -74,12 +75,14 @@
     "@octokit/request-error": "^2.1.0",
     "@octokit/rest": "^18.12.0",
     "@types/npm-package-arg": "^6.1.0",
+    "@xmldom/xmldom": "^0.8.2",
     "chalk": "^4.0.0",
     "code-suggester": "^2.0.0",
     "conventional-changelog-conventionalcommits": "^4.6.0",
     "conventional-changelog-writer": "^5.0.0",
     "conventional-commits-filter": "^2.0.2",
     "detect-indent": "^6.1.0",
+    "diff": "^5.0.0",
     "figures": "^3.0.0",
     "js-yaml": "^4.0.0",
     "jsonpath": "^1.1.1",
@@ -90,7 +93,6 @@
     "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"
   },