release-please 12.3.0 → 13.0.0-candidate.0

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

@@ -0,0 +1,106 @@
+"use strict";
+// Copyright 2021 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GoYoshi = void 0;
+const strategy_1 = require("../strategy");
+const changelog_1 = require("../updaters/changelog");
+const version_1 = require("../version");
+// Commits containing a scope prefixed with an item in this array will be
+// ignored when generating a release PR for the parent module.
+const IGNORED_SUB_MODULES = new Set([
+    'bigtable',
+    'bigquery',
+    'datastore',
+    'firestore',
+    'logging',
+    'pubsub',
+    'pubsublite',
+    'spanner',
+    'storage',
+]);
+const REGEN_PR_REGEX = /.*auto-regenerate.*/;
+const REGEN_ISSUE_REGEX = /(?<prefix>.*)\(#(?<pr>.*)\)(\n|$)/;
+class GoYoshi extends strategy_1.Strategy {
+    constructor(options) {
+        var _a;
+        options.changelogPath = (_a = options.changelogPath) !== null && _a !== void 0 ? _a : 'CHANGES.md';
+        super(options);
+    }
+    async buildUpdates(options) {
+        const updates = [];
+        const version = options.newVersion;
+        updates.push({
+            path: this.addPath(this.changelogPath),
+            createIfMissing: true,
+            updater: new changelog_1.Changelog({
+                version,
+                changelogEntry: options.changelogEntry,
+            }),
+        });
+        return updates;
+    }
+    postProcessCommits(commits) {
+        let regenCommit;
+        return commits.filter(commit => {
+            var _a, _b;
+            // ignore commits whose scope is in the list of ignored modules
+            if (IGNORED_SUB_MODULES.has(commit.scope || '')) {
+                return false;
+            }
+            // Only have a single entry of the nightly regen listed in the changelog.
+            // If there are more than one of these commits, append associated PR.
+            if (this.repository.owner === 'googleapis' &&
+                this.repository.repo === 'google-api-go-client' &&
+                REGEN_PR_REGEX.test(commit.message)) {
+                if (regenCommit) {
+                    const match = commit.message.match(REGEN_ISSUE_REGEX);
+                    if ((_a = match === null || match === void 0 ? void 0 : match.groups) === null || _a === void 0 ? void 0 : _a.pr) {
+                        regenCommit.references.push({
+                            action: 'refs',
+                            issue: match.groups.pr,
+                            prefix: '#',
+                        });
+                    }
+                    return false;
+                }
+                else {
+                    commit.sha = '';
+                    regenCommit = commit;
+                    const match = commit.bareMessage.match(REGEN_ISSUE_REGEX);
+                    if ((_b = match === null || match === void 0 ? void 0 : match.groups) === null || _b === void 0 ? void 0 : _b.pr) {
+                        regenCommit.references.push({
+                            action: 'refs',
+                            issue: match.groups.pr,
+                            prefix: '#',
+                        });
+                        regenCommit.bareMessage = match.groups.prefix.trim();
+                    }
+                }
+            }
+            return true;
+        });
+    }
+    // "closes" is a little presumptuous, let's just indicate that the
+    // PR references these other commits:
+    async buildReleaseNotes(conventionalCommits, newVersion, newVersionTag, latestRelease) {
+        const releaseNotes = await super.buildReleaseNotes(conventionalCommits, newVersion, newVersionTag, latestRelease);
+        return releaseNotes.replace(/, closes /g, ', refs ');
+    }
+    initialReleaseVersion() {
+        return version_1.Version.parse('0.1.0');
+    }
+}
+exports.GoYoshi = GoYoshi;
+//# sourceMappingURL=go-yoshi.js.map

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

@@ -0,0 +1,5 @@
+import { Strategy, BuildUpdatesOptions } from '../strategy';
+import { Update } from '../update';
+export declare class Go extends Strategy {
+    protected buildUpdates(options: BuildUpdatesOptions): Promise<Update[]>;
+}

package/build/src/{releasers → strategies}/go.js

@@ -14,22 +14,21 @@
 // limitations under the License.
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Go = void 0;
-const release_pr_1 = require("../release-pr");
 // Generic
 const changelog_1 = require("../updaters/changelog");
-class Go extends release_pr_1.ReleasePR {
-    constructor() {
-        super(...arguments);
-        this.enableSimplePrereleaseParsing = true;
-    }
-    async buildUpdates(changelogEntry, candidate, packageName) {
+const strategy_1 = require("../strategy");
+class Go extends strategy_1.Strategy {
+    async buildUpdates(options) {
         const updates = [];
-        updates.push(new changelog_1.Changelog({
+        const version = options.newVersion;
+        updates.push({
             path: this.addPath(this.changelogPath),
-            changelogEntry,
-            version: candidate.version,
-            packageName: packageName.name,
-        }));
+            createIfMissing: true,
+            updater: new changelog_1.Changelog({
+                version,
+                changelogEntry: options.changelogEntry,
+            }),
+        });
         return updates;
     }
 }

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

@@ -0,0 +1,8 @@
+import { Strategy, BuildUpdatesOptions } from '../strategy';
+import { Update } from '../update';
+export declare class Helm extends Strategy {
+    private chartYmlContents?;
+    protected buildUpdates(options: BuildUpdatesOptions): Promise<Update[]>;
+    getDefaultPackageName(): Promise<string | undefined>;
+    private getChartYmlContents;
+}

package/build/src/strategies/helm.js

@@ -0,0 +1,63 @@
+"use strict";
+// Copyright 2021 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Helm = void 0;
+// Generic
+const changelog_1 = require("../updaters/changelog");
+const yaml = require("js-yaml");
+// helm
+const chart_yaml_1 = require("../updaters/helm/chart-yaml");
+const strategy_1 = require("../strategy");
+class Helm extends strategy_1.Strategy {
+    async buildUpdates(options) {
+        const updates = [];
+        const version = options.newVersion;
+        updates.push({
+            path: this.addPath(this.changelogPath),
+            createIfMissing: true,
+            updater: new changelog_1.Changelog({
+                version,
+                changelogEntry: options.changelogEntry,
+            }),
+        });
+        updates.push({
+            path: this.addPath('Chart.yaml'),
+            createIfMissing: false,
+            cachedFileContents: this.chartYmlContents,
+            updater: new chart_yaml_1.ChartYaml({
+                version,
+            }),
+        });
+        return updates;
+    }
+    async getDefaultPackageName() {
+        const chartYmlContents = await this.getChartYmlContents();
+        const chart = yaml.load(chartYmlContents.parsedContent, { json: true });
+        if (typeof chart === 'object') {
+            return chart.name;
+        }
+        else {
+            return undefined;
+        }
+    }
+    async getChartYmlContents() {
+        if (!this.chartYmlContents) {
+            this.chartYmlContents = await this.github.getFileContents(this.addPath('Chart.yaml'));
+        }
+        return this.chartYmlContents;
+    }
+}
+exports.Helm = Helm;
+//# sourceMappingURL=helm.js.map

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

@@ -0,0 +1,24 @@
+import { Update } from '../update';
+import { Version, VersionsMap } from '../version';
+import { Strategy, StrategyOptions, BuildUpdatesOptions } from '../strategy';
+import { GitHubFileContents } from '../github';
+import { Commit } from '../commit';
+import { Release } from '../release';
+import { ReleasePullRequest } from '../release-pull-request';
+interface JavaStrategyOptions extends StrategyOptions {
+    extraFiles?: string[];
+}
+export declare class JavaYoshi extends Strategy {
+    readonly extraFiles: string[];
+    private versionsContent?;
+    private snapshotVersioning;
+    constructor(options: JavaStrategyOptions);
+    buildReleasePullRequest(commits: Commit[], latestRelease?: Release, draft?: boolean, labels?: string[]): Promise<ReleasePullRequest | undefined>;
+    private buildSnapshotPullRequest;
+    private needsSnapshot;
+    protected buildVersionsMap(): Promise<VersionsMap>;
+    protected getVersionsContent(): Promise<GitHubFileContents>;
+    protected buildUpdates(options: BuildUpdatesOptions): Promise<Update[]>;
+    protected initialReleaseVersion(): Version;
+}
+export {};

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

@@ -0,0 +1,203 @@
+"use strict";
+// Copyright 2021 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.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 strategy_1 = require("../strategy");
+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 strategy_1.Strategy {
+    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.extraFiles = options.extraFiles || [];
+        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 pullRequestBody = new pull_request_body_1.PullRequestBody([
+            {
+                component,
+                version: newVersion,
+                notes: '### Updating meta-information for bleeding-edge SNAPSHOT release.',
+            },
+        ]);
+        return {
+            title: pullRequestTitle,
+            body: pullRequestBody,
+            updates: [
+                {
+                    path: this.addPath('versions.txt'),
+                    createIfMissing: false,
+                    updater: new versions_manifest_1.VersionsManifest({
+                        version: newVersion,
+                        versionsMap,
+                    }),
+                },
+            ],
+            labels: [],
+            headRefName: branchName.toString(),
+            version: newVersion,
+            draft: false,
+        };
+    }
+    async needsSnapshot() {
+        return versions_manifest_1.VersionsManifest.needsSnapshot((await this.getVersionsContent()).parsedContent);
+    }
+    async buildVersionsMap() {
+        this.versionsContent = await this.getVersionsContent();
+        return versions_manifest_1.VersionsManifest.parseVersions(this.versionsContent.parsedContent);
+    }
+    async getVersionsContent() {
+        if (!this.versionsContent) {
+            try {
+                this.versionsContent = await this.github.getFileContentsOnBranch(this.addPath('versions.txt'), this.targetBranch);
+            }
+            catch (err) {
+                if (err instanceof errors_1.GitHubAPIError) {
+                    throw new errors_1.MissingRequiredFileError(this.addPath('versions.txt'), JavaYoshi.name, `${this.repository.owner}/${this.repository.repo}`);
+                }
+                throw err;
+            }
+        }
+        return this.versionsContent;
+    }
+    async buildUpdates(options) {
+        const updates = [];
+        const version = options.newVersion;
+        const versionsMap = options.versionsMap;
+        updates.push({
+            path: this.addPath('versions.txt'),
+            createIfMissing: false,
+            cachedFileContents: this.versionsContent,
+            updater: new versions_manifest_1.VersionsManifest({
+                version,
+                versionsMap,
+            }),
+        });
+        const pomFilesSearch = this.github.findFilesByFilename('pom.xml', this.path);
+        const buildFilesSearch = this.github.findFilesByFilename('build.gradle', this.path);
+        const dependenciesSearch = this.github.findFilesByFilename('dependencies.properties', this.path);
+        const pomFiles = await pomFilesSearch;
+        pomFiles.forEach(path => {
+            updates.push({
+                path: this.addPath(path),
+                createIfMissing: false,
+                updater: new java_update_1.JavaUpdate({
+                    version,
+                    versionsMap,
+                }),
+            });
+        });
+        const buildFiles = await buildFilesSearch;
+        buildFiles.forEach(path => {
+            updates.push({
+                path: this.addPath(path),
+                createIfMissing: false,
+                updater: new java_update_1.JavaUpdate({
+                    version,
+                    versionsMap,
+                }),
+            });
+        });
+        const dependenciesFiles = await dependenciesSearch;
+        dependenciesFiles.forEach(path => {
+            updates.push({
+                path: this.addPath(path),
+                createIfMissing: false,
+                updater: new java_update_1.JavaUpdate({
+                    version,
+                    versionsMap,
+                }),
+            });
+        });
+        this.extraFiles.forEach(path => {
+            updates.push({
+                path,
+                createIfMissing: false,
+                updater: new java_update_1.JavaUpdate({
+                    version,
+                    versionsMap,
+                }),
+            });
+        });
+        updates.push({
+            path: this.addPath(this.changelogPath),
+            createIfMissing: true,
+            updater: new changelog_1.Changelog({
+                version,
+                changelogEntry: options.changelogEntry,
+            }),
+        });
+        return updates;
+    }
+    initialReleaseVersion() {
+        return version_1.Version.parse('0.1.0');
+    }
+}
+exports.JavaYoshi = JavaYoshi;
+//# sourceMappingURL=java-yoshi.js.map

package/build/src/strategies/krm-blueprint.d.ts

@@ -0,0 +1,7 @@
+import { Strategy, BuildUpdatesOptions } from '../strategy';
+import { Update } from '../update';
+import { Version } from '../version';
+export declare class KRMBlueprint extends Strategy {
+    protected buildUpdates(options: BuildUpdatesOptions): Promise<Update[]>;
+    protected initialReleaseVersion(): Version;
+}

package/build/src/{releasers → strategies}/krm-blueprint.js

@@ -14,46 +14,50 @@
 // limitations under the License.
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.KRMBlueprint = void 0;
-const release_pr_1 = require("../release-pr");
 // Generic
 const changelog_1 = require("../updaters/changelog");
 // KRM specific.
 const krm_blueprint_version_1 = require("../updaters/krm/krm-blueprint-version");
+const strategy_1 = require("../strategy");
+const version_1 = require("../version");
 const KRMBlueprintAttribAnnotation = 'cnrm.cloud.google.com/blueprint';
 const hasKRMBlueprintAttrib = (content) => content.includes(KRMBlueprintAttribAnnotation);
-class KRMBlueprint extends release_pr_1.ReleasePR {
-    async buildUpdates(changelogEntry, candidate, packageName) {
+class KRMBlueprint extends strategy_1.Strategy {
+    async buildUpdates(options) {
         const updates = [];
-        updates.push(new changelog_1.Changelog({
+        const version = options.newVersion;
+        updates.push({
             path: this.addPath(this.changelogPath),
-            changelogEntry,
-            version: candidate.version,
-            packageName: packageName.name,
-        }));
+            createIfMissing: true,
+            updater: new changelog_1.Changelog({
+                version,
+                changelogEntry: options.changelogEntry,
+            }),
+        });
         const versionsMap = new Map();
-        if (candidate.previousTag) {
-            // if previousTag of form pkgName-vX.x.x, we only require vX.x.x for attrib update
-            const previousVersion = candidate.previousTag.replace(`${packageName.name}-`, '');
-            versionsMap.set('previousVersion', previousVersion);
+        if (options.latestVersion) {
+            versionsMap.set('previousVersion', options.latestVersion);
         }
         // Update version in all yaml files with attribution annotation
-        const yamlPaths = await this.gh.findFilesByExtension('yaml', this.path);
+        const yamlPaths = await this.github.findFilesByExtension('yaml', this.path);
         for (const yamlPath of yamlPaths) {
-            const contents = await this.gh.getFileContents(this.addPath(yamlPath));
+            const contents = await this.github.getFileContents(this.addPath(yamlPath));
             if (hasKRMBlueprintAttrib(contents.parsedContent)) {
-                updates.push(new krm_blueprint_version_1.KRMBlueprintVersion({
+                updates.push({
                     path: this.addPath(yamlPath),
-                    changelogEntry,
-                    version: candidate.version,
-                    packageName: packageName.name,
-                    versions: versionsMap,
-                }));
+                    createIfMissing: false,
+                    cachedFileContents: contents,
+                    updater: new krm_blueprint_version_1.KRMBlueprintVersion({
+                        version,
+                        versionsMap,
+                    }),
+                });
             }
         }
         return updates;
     }
-    defaultInitialVersion() {
-        return '0.1.0';
+    initialReleaseVersion() {
+        return version_1.Version.parse('0.1.0');
     }
 }
 exports.KRMBlueprint = KRMBlueprint;

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

@@ -0,0 +1,9 @@
+import { Strategy, BuildUpdatesOptions } from '../strategy';
+import { Update } from '../update';
+export declare class Node extends Strategy {
+    private pkgJsonContents?;
+    protected buildUpdates(options: BuildUpdatesOptions): Promise<Update[]>;
+    getDefaultPackageName(): Promise<string | undefined>;
+    protected normalizeComponent(component: string | undefined): string;
+    private getPkgJsonContents;
+}

package/build/src/strategies/node.js

@@ -0,0 +1,82 @@
+"use strict";
+// Copyright 2019 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.Node = void 0;
+const strategy_1 = require("../strategy");
+const package_lock_json_1 = require("../updaters/node/package-lock-json");
+const samples_package_json_1 = require("../updaters/node/samples-package-json");
+const changelog_1 = require("../updaters/changelog");
+const package_json_1 = require("../updaters/node/package-json");
+class Node extends strategy_1.Strategy {
+    async buildUpdates(options) {
+        const updates = [];
+        const version = options.newVersion;
+        const packageName = this.component || '';
+        const lockFiles = ['package-lock.json', 'npm-shrinkwrap.json'];
+        lockFiles.forEach(lockFile => {
+            updates.push({
+                path: this.addPath(lockFile),
+                createIfMissing: false,
+                updater: new package_lock_json_1.PackageLockJson({
+                    version,
+                }),
+            });
+        });
+        updates.push({
+            path: this.addPath('samples/package.json'),
+            createIfMissing: false,
+            updater: new samples_package_json_1.SamplesPackageJson({
+                version,
+                packageName,
+            }),
+        });
+        updates.push({
+            path: this.addPath(this.changelogPath),
+            createIfMissing: true,
+            updater: new changelog_1.Changelog({
+                version,
+                changelogEntry: options.changelogEntry,
+            }),
+        });
+        updates.push({
+            path: this.addPath('package.json'),
+            createIfMissing: false,
+            cachedFileContents: this.pkgJsonContents,
+            updater: new package_json_1.PackageJson({
+                version,
+            }),
+        });
+        return updates;
+    }
+    async getDefaultPackageName() {
+        const pkgJsonContents = await this.getPkgJsonContents();
+        const pkg = JSON.parse(pkgJsonContents.parsedContent);
+        return pkg.name;
+    }
+    normalizeComponent(component) {
+        if (!component) {
+            return '';
+        }
+        return component.match(/^@[\w-]+\//) ? component.split('/')[1] : component;
+    }
+    async getPkgJsonContents() {
+        if (!this.pkgJsonContents) {
+            this.pkgJsonContents = await this.github.getFileContentsOnBranch(this.addPath('package.json'), this.targetBranch);
+        }
+        return this.pkgJsonContents;
+    }
+}
+exports.Node = Node;
+//# sourceMappingURL=node.js.map

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

@@ -0,0 +1,5 @@
+import { Strategy, BuildUpdatesOptions } from '../strategy';
+import { Update } from '../update';
+export declare class OCaml extends Strategy {
+    protected buildUpdates(options: BuildUpdatesOptions): Promise<Update[]>;
+}