release-please 13.7.1 → 13.9.0

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

@@ -0,0 +1,96 @@
+"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.DotnetYoshi = void 0;
+const base_1 = require("./base");
+const changelog_1 = require("../updaters/changelog");
+const apis_1 = require("../updaters/dotnet/apis");
+const logger_1 = require("../util/logger");
+const errors_1 = require("../errors");
+const CHANGELOG_SECTIONS = [
+    { type: 'feat', section: 'New features' },
+    { type: 'fix', section: 'Bug fixes' },
+    { type: 'perf', section: 'Performance improvements' },
+    { type: 'revert', section: 'Reverts' },
+    { type: 'chore', section: 'Miscellaneous chores', hidden: true },
+    { type: 'docs', section: 'Documentation improvements' },
+    { type: 'style', section: 'Styles', hidden: true },
+    { type: 'refactor', section: 'Code Refactoring', hidden: true },
+    { type: 'test', section: 'Tests', hidden: true },
+    { type: 'build', section: 'Build System', hidden: true },
+    { type: 'ci', section: 'Continuous Integration', hidden: true },
+];
+const DEFAULT_CHANGELOG_PATH = 'docs/history.md';
+const DEFAULT_PULL_REQUEST_TITLE_PATTERN = 'Release${component} version ${version}';
+const RELEASE_NOTES_HEADER_PATTERN = /#{2,3} \[?(\d+\.\d+\.\d+-?[^\]]*)\]?.* \((\d{4}-\d{2}-\d{2})\)/;
+class DotnetYoshi extends base_1.BaseStrategy {
+    constructor(options) {
+        var _a, _b, _c, _d;
+        options.changelogSections = (_a = options.changelogSections) !== null && _a !== void 0 ? _a : CHANGELOG_SECTIONS;
+        options.changelogPath = (_b = options.changelogPath) !== null && _b !== void 0 ? _b : DEFAULT_CHANGELOG_PATH;
+        options.pullRequestTitlePattern = (_c = options.pullRequestTitlePattern) !== null && _c !== void 0 ? _c : DEFAULT_PULL_REQUEST_TITLE_PATTERN;
+        options.includeVInTag = (_d = options.includeVInTag) !== null && _d !== void 0 ? _d : false;
+        super(options);
+    }
+    async buildReleaseNotes(conventionalCommits, newVersion, newVersionTag, latestRelease) {
+        const notes = await super.buildReleaseNotes(conventionalCommits, newVersion, newVersionTag, latestRelease);
+        return notes.replace(RELEASE_NOTES_HEADER_PATTERN, '## Version $1, released $2');
+    }
+    async getApi() {
+        try {
+            const contents = await this.github.getFileContentsOnBranch('apis/apis.json', this.targetBranch);
+            const apis = JSON.parse(contents.parsedContent);
+            const component = await this.getComponent();
+            return apis.apis.find(api => api.id === component);
+        }
+        catch (e) {
+            if (e instanceof errors_1.FileNotFoundError) {
+                throw new errors_1.MissingRequiredFileError('apis/apis.json', DotnetYoshi.name, `${this.repository.owner}/${this.repository.repo}`);
+            }
+            throw e;
+        }
+    }
+    async buildUpdates(options) {
+        const updates = [];
+        const version = options.newVersion;
+        const component = await this.getComponent();
+        const api = await this.getApi();
+        if (api === null || api === void 0 ? void 0 : api.noVersionHistory) {
+            logger_1.logger.info(`Skipping changelog for ${component} via noVersionHistory configuration`);
+        }
+        else {
+            updates.push({
+                path: this.addPath(this.changelogPath),
+                createIfMissing: true,
+                updater: new changelog_1.Changelog({
+                    version,
+                    changelogEntry: options.changelogEntry,
+                }),
+            });
+        }
+        if (!this.component) {
+            logger_1.logger.warn('Dotnet strategy expects to use components, could not update all files');
+            return updates;
+        }
+        updates.push({
+            path: 'apis/apis.json',
+            createIfMissing: false,
+            updater: new apis_1.Apis(this.component, version),
+        });
+        return updates;
+    }
+}
+exports.DotnetYoshi = DotnetYoshi;
+//# sourceMappingURL=dotnet-yoshi.js.map

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

@@ -1,30 +1,20 @@
 import { Update } from '../update';
 import { Version, VersionsMap } from '../version';
-import { BaseStrategy, BuildUpdatesOptions, BaseStrategyOptions } from './base';
 import { GitHubFileContents } from '../util/file-cache';
-import { Commit, ConventionalCommit } from '../commit';
-import { Release } from '../release';
-import { ReleasePullRequest } from '../release-pull-request';
-interface JavaBuildUpdatesOption extends BuildUpdatesOptions {
-    isSnapshot?: boolean;
-}
-export declare class JavaYoshi extends BaseStrategy {
+import { ConventionalCommit } from '../commit';
+import { Java, JavaBuildUpdatesOption } from './java';
+export declare class JavaYoshi extends Java {
     private versionsContent?;
-    private snapshotVersioning;
-    constructor(options: BaseStrategyOptions);
-    buildReleasePullRequest(commits: Commit[], latestRelease?: Release, draft?: boolean, labels?: string[]): Promise<ReleasePullRequest | undefined>;
-    private buildSnapshotPullRequest;
     /**
      * Override this method to post process commits
      * @param {ConventionalCommit[]} commits parsed commits
      * @returns {ConventionalCommit[]} modified commits
      */
     protected postProcessCommits(commits: ConventionalCommit[]): Promise<ConventionalCommit[]>;
-    private needsSnapshot;
+    protected needsSnapshot(): Promise<boolean>;
     protected buildVersionsMap(): Promise<VersionsMap>;
     protected getVersionsContent(): Promise<GitHubFileContents>;
     protected buildUpdates(options: JavaBuildUpdatesOption): Promise<Update[]>;
     protected updateVersionsMap(versionsMap: VersionsMap, conventionalCommits: ConventionalCommit[]): Promise<VersionsMap>;
     protected initialReleaseVersion(): Version;
 }
-export {};

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

@@ -16,92 +16,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.JavaYoshi = void 0;
 const versions_manifest_1 = require("../updaters/java/versions-manifest");
 const version_1 = require("../version");
-const java_update_1 = require("../updaters/java/java-update");
-const base_1 = require("./base");
 const changelog_1 = require("../updaters/changelog");
-const java_snapshot_1 = require("../versioning-strategies/java-snapshot");
 const errors_1 = require("../errors");
 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 default_1 = require("../versioning-strategies/default");
-const java_add_snapshot_1 = require("../versioning-strategies/java-add-snapshot");
-const CHANGELOG_SECTIONS = [
-    { type: 'feat', section: 'Features' },
-    { type: 'fix', section: 'Bug Fixes' },
-    { type: 'perf', section: 'Performance Improvements' },
-    { type: 'deps', section: 'Dependencies' },
-    { type: 'revert', section: 'Reverts' },
-    { type: 'docs', section: 'Documentation' },
-    { type: 'style', section: 'Styles', hidden: true },
-    { type: 'chore', section: 'Miscellaneous Chores', hidden: true },
-    { type: 'refactor', section: 'Code Refactoring', hidden: true },
-    { type: 'test', section: 'Tests', hidden: true },
-    { type: 'build', section: 'Build System', hidden: true },
-    { type: 'ci', section: 'Continuous Integration', hidden: true },
-];
-class JavaYoshi extends base_1.BaseStrategy {
-    constructor(options) {
-        var _a;
-        options.changelogSections = (_a = options.changelogSections) !== null && _a !== void 0 ? _a : CHANGELOG_SECTIONS;
-        // wrap the configured versioning strategy with snapshotting
-        const parentVersioningStrategy = options.versioningStrategy || new default_1.DefaultVersioningStrategy();
-        options.versioningStrategy = new java_snapshot_1.JavaSnapshot(parentVersioningStrategy);
-        super(options);
-        this.snapshotVersioning = new java_add_snapshot_1.JavaAddSnapshot(parentVersioningStrategy);
-    }
-    async buildReleasePullRequest(commits, latestRelease, draft, labels = []) {
-        if (await this.needsSnapshot()) {
-            logger_1.logger.info('Repository needs a snapshot bump.');
-            return await this.buildSnapshotPullRequest(latestRelease);
-        }
-        logger_1.logger.info('No Java snapshot needed');
-        return await super.buildReleasePullRequest(commits, latestRelease, draft, labels);
-    }
-    async buildSnapshotPullRequest(latestRelease) {
-        const component = await this.getComponent();
-        const newVersion = latestRelease
-            ? await this.snapshotVersioning.bump(latestRelease.tag.version, [])
-            : this.initialReleaseVersion();
-        const versionsMap = await this.buildVersionsMap();
-        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.snapshotVersioning.bump(version, []);
-            versionsMap.set(versionKey, newVersion);
-        }
-        const pullRequestTitle = pull_request_title_1.PullRequestTitle.ofComponentTargetBranchVersion(component || '', this.targetBranch, newVersion);
-        const branchName = component
-            ? branch_name_1.BranchName.ofComponentTargetBranch(component, this.targetBranch)
-            : branch_name_1.BranchName.ofTargetBranch(this.targetBranch);
-        const notes = '### Updating meta-information for bleeding-edge SNAPSHOT release.';
-        const pullRequestBody = new pull_request_body_1.PullRequestBody([
-            {
-                component,
-                version: newVersion,
-                notes,
-            },
-        ]);
-        const updates = await this.buildUpdates({
-            newVersion,
-            versionsMap,
-            changelogEntry: notes,
-            isSnapshot: true,
-        });
-        return {
-            title: pullRequestTitle,
-            body: pullRequestBody,
-            updates,
-            labels: [],
-            headRefName: branchName.toString(),
-            version: newVersion,
-            draft: false,
-        };
-    }
+const java_1 = require("./java");
+const java_update_1 = require("../updaters/java/java-update");
+class JavaYoshi extends java_1.Java {
     /**
      * Override this method to post process commits
      * @param {ConventionalCommit[]} commits parsed commits

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

@@ -0,0 +1,28 @@
+import { Update } from '../update';
+import { Version } from '../version';
+import { BaseStrategy, BaseStrategyOptions, BuildUpdatesOptions } from './base';
+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;
+}
+/**
+ * A strategy that generates SNAPSHOT version after each release, which is standard especially in Maven projects.
+ *
+ * This is universal strategy that does not update any files on its own. Use maven strategy for Maven projects.
+ */
+export declare class Java extends BaseStrategy {
+    protected readonly snapshotVersioning: VersioningStrategy;
+    protected readonly snapshotLabels: string[];
+    constructor(options: JavaStrategyOptions);
+    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;
+    protected needsSnapshot(commits: Commit[], latestRelease?: Release): Promise<boolean>;
+    protected buildUpdates(options: JavaBuildUpdatesOption): Promise<Update[]>;
+}

package/build/src/strategies/java.js

@@ -0,0 +1,160 @@
+"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.Java = void 0;
+const base_1 = require("./base");
+const changelog_1 = require("../updaters/changelog");
+const java_snapshot_1 = require("../versioning-strategies/java-snapshot");
+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 default_1 = require("../versioning-strategies/default");
+const java_add_snapshot_1 = require("../versioning-strategies/java-add-snapshot");
+const manifest_1 = require("../manifest");
+const java_released_1 = require("../updaters/java/java-released");
+const composite_1 = require("../updaters/composite");
+const CHANGELOG_SECTIONS = [
+    { type: 'feat', section: 'Features' },
+    { type: 'fix', section: 'Bug Fixes' },
+    { type: 'perf', section: 'Performance Improvements' },
+    { type: 'deps', section: 'Dependencies' },
+    { type: 'revert', section: 'Reverts' },
+    { type: 'docs', section: 'Documentation' },
+    { type: 'style', section: 'Styles', hidden: true },
+    { type: 'chore', section: 'Miscellaneous Chores', hidden: true },
+    { type: 'refactor', section: 'Code Refactoring', hidden: true },
+    { type: 'test', section: 'Tests', hidden: true },
+    { type: 'build', section: 'Build System', hidden: true },
+    { type: 'ci', section: 'Continuous Integration', hidden: true },
+];
+/**
+ * A strategy that generates SNAPSHOT version after each release, which is standard especially in Maven projects.
+ *
+ * This is universal strategy that does not update any files on its own. Use maven strategy for Maven projects.
+ */
+class Java extends base_1.BaseStrategy {
+    constructor(options) {
+        var _a;
+        options.changelogSections = (_a = options.changelogSections) !== null && _a !== void 0 ? _a : CHANGELOG_SECTIONS;
+        // wrap the configured versioning strategy with snapshotting
+        const parentVersioningStrategy = options.versioningStrategy || new default_1.DefaultVersioningStrategy();
+        options.versioningStrategy = new java_snapshot_1.JavaSnapshot(parentVersioningStrategy);
+        super(options);
+        this.snapshotVersioning = new java_add_snapshot_1.JavaAddSnapshot(parentVersioningStrategy);
+        this.snapshotLabels = options.snapshotLabels || manifest_1.DEFAULT_SNAPSHOT_LABELS;
+    }
+    async buildReleasePullRequest(commits, latestRelease, draft, labels = []) {
+        if (await this.needsSnapshot(commits, latestRelease)) {
+            logger_1.logger.info('Repository needs a snapshot bump.');
+            return await this.buildSnapshotPullRequest(latestRelease, draft, this.snapshotLabels);
+        }
+        logger_1.logger.info('No Java snapshot needed');
+        return await super.buildReleasePullRequest(commits, latestRelease, draft, labels);
+    }
+    async buildSnapshotPullRequest(latestRelease, draft, labels = []) {
+        const component = await this.getComponent();
+        const newVersion = latestRelease
+            ? await this.snapshotVersioning.bump(latestRelease.tag.version, [])
+            : this.initialReleaseVersion();
+        const versionsMap = await this.buildVersionsMap([]);
+        const pullRequestTitle = pull_request_title_1.PullRequestTitle.ofComponentTargetBranchVersion(component || '', this.targetBranch, newVersion);
+        const branchName = component
+            ? branch_name_1.BranchName.ofComponentTargetBranch(component, this.targetBranch)
+            : branch_name_1.BranchName.ofTargetBranch(this.targetBranch);
+        const notes = '### Updating meta-information for bleeding-edge SNAPSHOT release.';
+        const pullRequestBody = new pull_request_body_1.PullRequestBody([
+            {
+                component,
+                version: newVersion,
+                notes,
+            },
+        ]);
+        const updates = await this.buildUpdates({
+            newVersion,
+            versionsMap,
+            changelogEntry: notes,
+            isSnapshot: true,
+        });
+        const updatesWithExtras = composite_1.mergeUpdates(updates.concat(...this.extraFileUpdates(newVersion, versionsMap)));
+        return {
+            title: pullRequestTitle,
+            body: pullRequestBody,
+            updates: updatesWithExtras,
+            labels: labels,
+            headRefName: branchName.toString(),
+            version: newVersion,
+            draft: draft !== null && draft !== void 0 ? draft : false,
+        };
+    }
+    isPublishedVersion(version) {
+        return !version.preRelease || version.preRelease.indexOf('SNAPSHOT') < 0;
+    }
+    async needsSnapshot(commits, latestRelease) {
+        var _a;
+        const component = await this.getComponent();
+        logger_1.logger.debug('component:', component);
+        const version = (_a = latestRelease === null || latestRelease === void 0 ? void 0 : latestRelease.tag) === null || _a === void 0 ? void 0 : _a.version;
+        if (!version) {
+            // Don't bump snapshots for the first release ever
+            return false;
+        }
+        // Found snapshot as a release, this is unexpected, but use it
+        if (!this.isPublishedVersion(version)) {
+            return false;
+        }
+        // Search commits for snapshot bump
+        const pullRequests = commits
+            .map(commit => {
+            var _a;
+            return pull_request_title_1.PullRequestTitle.parse(((_a = commit.pullRequest) === null || _a === void 0 ? void 0 : _a.title) || commit.message, this.pullRequestTitlePattern);
+        })
+            .filter(pullRequest => pullRequest);
+        const snapshotCommits = pullRequests
+            .filter(pullRequest => ((pullRequest === null || pullRequest === void 0 ? void 0 : pullRequest.component) || '') === component)
+            .map(pullRequest => pullRequest === null || pullRequest === void 0 ? void 0 : pullRequest.getVersion())
+            .filter(version => version && !this.isPublishedVersion(version));
+        return snapshotCommits.length === 0;
+    }
+    async buildUpdates(options) {
+        const version = options.newVersion;
+        const versionsMap = options.versionsMap;
+        const updates = [];
+        if (!options.isSnapshot) {
+            // Append java-specific updater for extraFiles
+            this.extraFiles.forEach(extraFile => {
+                if (typeof extraFile === 'string') {
+                    updates.push({
+                        path: this.addPath(extraFile),
+                        createIfMissing: false,
+                        updater: new java_released_1.JavaReleased({ version, versionsMap }),
+                    });
+                }
+            });
+            // Update changelog
+            updates.push({
+                path: this.addPath(this.changelogPath),
+                createIfMissing: true,
+                updater: new changelog_1.Changelog({
+                    version,
+                    changelogEntry: options.changelogEntry,
+                }),
+            });
+        }
+        return updates;
+    }
+}
+exports.Java = Java;
+//# sourceMappingURL=java.js.map

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

@@ -0,0 +1,9 @@
+import { Java, JavaBuildUpdatesOption } from './java';
+import { Update } from '../update';
+/**
+ * Strategy for Maven projects. It generates SNAPSHOT version after each release, and updates all found
+ * pom.xml files automatically.
+ */
+export declare class Maven extends Java {
+    protected buildUpdates(options: JavaBuildUpdatesOption): Promise<Update[]>;
+}

package/build/src/strategies/maven.js

@@ -0,0 +1,56 @@
+"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.Maven = void 0;
+const java_1 = require("./java");
+const java_released_1 = require("../updaters/java/java-released");
+const generic_1 = require("../updaters/generic");
+const pom_xml_1 = require("../updaters/java/pom-xml");
+/**
+ * Strategy for Maven projects. It generates SNAPSHOT version after each release, and updates all found
+ * pom.xml files automatically.
+ */
+class Maven extends java_1.Java {
+    async buildUpdates(options) {
+        const version = options.newVersion;
+        const versionsMap = options.versionsMap;
+        // Use generic Java updates
+        const updates = await super.buildUpdates(options);
+        // Update pom.xml files
+        const pomFiles = await this.github.findFilesByFilenameAndRef('pom.xml', this.targetBranch, this.path);
+        pomFiles.forEach(path => {
+            updates.push({
+                path: this.addPath(path),
+                createIfMissing: false,
+                updater: new pom_xml_1.PomXml(version),
+            });
+            if (!options.isSnapshot) {
+                updates.push({
+                    path: this.addPath(path),
+                    createIfMissing: false,
+                    updater: new java_released_1.JavaReleased({ version, versionsMap }),
+                });
+            }
+            updates.push({
+                path: this.addPath(path),
+                createIfMissing: false,
+                updater: new generic_1.Generic({ version, versionsMap }),
+            });
+        });
+        return updates;
+    }
+}
+exports.Maven = Maven;
+//# sourceMappingURL=maven.js.map

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

@@ -28,6 +28,7 @@ const tag_name_1 = require("../util/tag-name");
 const pull_request_title_1 = require("../util/pull-request-title");
 const branch_name_1 = require("../util/branch-name");
 const pull_request_body_1 = require("../util/pull-request-body");
+const errors_1 = require("../errors");
 const CHANGELOG_SECTIONS = [
     { type: 'feat', section: 'Features' },
     { type: 'fix', section: 'Bug Fixes' },
@@ -89,7 +90,7 @@ class PHPYoshi extends base_1.BaseStrategy {
                 releaseNotesBody = updatePHPChangelogEntry(`${composer.name} ${newVersion.toString()}`, releaseNotesBody, partialReleaseNotes);
             }
             catch (err) {
-                if (err.status === 404) {
+                if (err instanceof errors_1.FileNotFoundError) {
                     // if the updated path has no VERSION, assume this isn't a
                     // module that needs updating.
                     continue;

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

@@ -1,9 +1,9 @@
 import { BaseStrategy, BuildUpdatesOptions, BaseStrategyOptions } from './base';
-import { ConventionalCommit } from '../commit';
+import { ConventionalCommit, Commit } from '../commit';
 import { Update } from '../update';
 import { Release } from '../release';
+import { TagName } from '../util/tag-name';
 import { Version } from '../version';
-import { PullRequestBody } from '../util/pull-request-body';
 interface RubyYoshiStrategyOptions extends BaseStrategyOptions {
     versionFile?: string;
 }
@@ -12,6 +12,6 @@ export declare class RubyYoshi extends BaseStrategy {
     constructor(options: RubyYoshiStrategyOptions);
     protected buildUpdates(options: BuildUpdatesOptions): Promise<Update[]>;
     protected postProcessCommits(commits: ConventionalCommit[]): Promise<ConventionalCommit[]>;
-    protected buildPullRequestBody(component: string | undefined, newVersion: Version, releaseNotesBody: string, conventionalCommits: ConventionalCommit[], latestRelease?: Release): Promise<PullRequestBody>;
+    protected buildReleaseNotes(conventionalCommits: ConventionalCommit[], newVersion: Version, newVersionTag: TagName, latestRelease?: Release, commits?: Commit[]): Promise<string>;
 }
 export {};

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

@@ -22,9 +22,6 @@ const version_rb_1 = require("../updaters/ruby/version-rb");
 const base_1 = require("./base");
 const fs_1 = require("fs");
 const path_1 = require("path");
-const manifest_1 = require("../manifest");
-const logger_1 = require("../util/logger");
-const pull_request_body_1 = require("../util/pull-request-body");
 const CHANGELOG_SECTIONS = [
     { type: 'feat', section: 'Features' },
     { type: 'fix', section: 'Bug Fixes' },
@@ -80,49 +77,17 @@ class RubyYoshi extends base_1.BaseStrategy {
         });
         return commits;
     }
-    async buildPullRequestBody(component, newVersion, releaseNotesBody, conventionalCommits, latestRelease) {
-        if (!latestRelease) {
-            return await super.buildPullRequestBody(component, newVersion, releaseNotesBody, conventionalCommits, latestRelease);
-        }
-        // summarize the commits that landed:
-        let summary = '### Commits since last release:\n\n';
-        const updatedFiles = {};
-        const repoUrl = `${this.repository.owner}/${this.repository.repo}`;
-        for (const commit of conventionalCommits) {
-            if (!commit.sha)
-                continue;
-            const splitMessage = commit.message.split('\n');
-            summary += `* [${splitMessage[0]}](https://github.com/${repoUrl}/commit/${commit.sha})\n`;
-            if (splitMessage.length > 2) {
-                summary = `${summary}<pre><code>${splitMessage
-                    .slice(1)
-                    .join('\n')}</code></pre>\n`;
-            }
-            if (commit.files === undefined) {
-                logger_1.logger.error('No files for commit - this is likely a bug.');
-                continue;
-            }
-            commit.files.forEach(file => {
-                if (this.path === manifest_1.ROOT_PROJECT_PATH || file.startsWith(this.path)) {
-                    updatedFiles[file] = true;
-                }
-            });
-        }
-        // summarize the files that changed:
-        summary = `${summary}\n### Files edited since last release:\n\n<pre><code>`;
-        Object.keys(updatedFiles).forEach(file => {
-            summary += `${file}\n`;
-        });
-        summary += `</code></pre>\n[Compare Changes](https://github.com/${repoUrl}/compare/${latestRelease.sha}...HEAD)\n`;
-        return new pull_request_body_1.PullRequestBody([
-            {
-                component,
-                version: newVersion,
-                notes: releaseNotesBody,
-            },
-        ], {
-            extra: summary,
-        });
+    async buildReleaseNotes(conventionalCommits, newVersion, newVersionTag, latestRelease, commits) {
+        const releaseNotes = await super.buildReleaseNotes(conventionalCommits, newVersion, newVersionTag, latestRelease, commits);
+        return (releaseNotes
+            // Remove links in version title line and standardize on h3
+            .replace(/^###? \[([\d.]+)\]\([^)]*\)/gm, '### $1')
+            // Remove PR and commit links from pull request title suffixes
+            .replace(/ \(\[#\d+\]\([^)]*\)\)( \(\[\w+\]\([^)]*\)\))?\s*$/gm, '')
+            // Standardize on h4 for change type subheaders
+            .replace(/^### (Features|Bug Fixes|Documentation)$/gm, '#### $1')
+            // Collapse 2 or more blank lines
+            .replace(/\n{3,}/g, '\n\n'));
     }
 }
 exports.RubyYoshi = RubyYoshi;

package/build/src/strategy.d.ts

@@ -4,6 +4,7 @@ import { PullRequest } from './pull-request';
 import { Commit } from './commit';
 import { VersioningStrategy } from './versioning-strategy';
 import { ChangelogNotes } from './changelog-notes';
+import { Version } from './version';
 /**
  * A strategy is responsible for determining which files are
  * necessary to update in a release pull request.
@@ -35,4 +36,10 @@ export interface Strategy {
      * @returns {string}
      */
     getComponent(): Promise<string | undefined>;
+    /**
+     * Validate whether version is a valid release.
+     * @param version Released version.
+     * @returns true of release is valid, false if it should be skipped.
+     */
+    isPublishedVersion?(version: Version): boolean;
 }

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

@@ -0,0 +1,19 @@
+import { Updater } from '../update';
+/**
+ * Base class for all updaters working with XML files.
+ */
+export declare abstract class BaseXml implements Updater {
+    /**
+     * Given initial file contents, return updated contents.
+     * @param {string} content The initial content
+     * @returns {string} The updated content
+     */
+    updateContent(content: string): string;
+    /**
+     * Updates the document in-place if needed.
+     * @param document Document to be modified.
+     * @return true if document has been changed and therefore file needs to be changed, false otherwise.
+     * @protected
+     */
+    protected abstract updateDocument(document: Document): boolean;
+}