release-please 12.5.0 → 13.0.0-candidate.2

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

@@ -14,49 +14,48 @@
 // limitations under the License.
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Ruby = void 0;
-const release_pr_1 = require("../release-pr");
 const indent_commit_1 = require("../util/indent-commit");
 // Generic
 const changelog_1 = require("../updaters/changelog");
 // Ruby
-const version_rb_1 = require("../updaters/version-rb");
-class Ruby extends release_pr_1.ReleasePR {
+const version_rb_1 = require("../updaters/ruby/version-rb");
+const strategy_1 = require("../strategy");
+class Ruby extends strategy_1.Strategy {
     constructor(options) {
         var _a;
         super(options);
         this.versionFile = (_a = options.versionFile) !== null && _a !== void 0 ? _a : '';
+        this.tagSeparator = '/';
     }
-    async buildUpdates(changelogEntry, candidate, packageName) {
+    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,
+            }),
+        });
         const versionFile = this.versionFile
             ? this.versionFile
-            : `lib/${packageName.name.replace(/-/g, '/')}/version.rb`;
-        updates.push(new changelog_1.Changelog({
-            path: this.addPath(this.changelogPath),
-            changelogEntry,
-            version: candidate.version,
-            packageName: packageName.name,
-        }));
-        updates.push(new version_rb_1.VersionRB({
+            : `lib/${(this.component || '').replace(/-/g, '/')}/version.rb`;
+        updates.push({
             path: this.addPath(versionFile),
-            changelogEntry,
-            version: candidate.version,
-            packageName: packageName.name,
-        }));
+            createIfMissing: false,
+            updater: new version_rb_1.VersionRB({
+                version,
+            }),
+        });
         return updates;
     }
-    tagSeparator() {
-        return '/';
-    }
-    async commits(opts) {
-        return postProcessCommits(await super.commits(opts));
+    postProcessCommits(commits) {
+        commits.forEach(commit => {
+            commit.message = indent_commit_1.indentCommit(commit);
+        });
+        return commits;
     }
 }
 exports.Ruby = Ruby;
-function postProcessCommits(commits) {
-    commits.forEach(commit => {
-        commit.message = indent_commit_1.indentCommit(commit);
-    });
-    return commits;
-}
 //# sourceMappingURL=ruby.js.map

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

@@ -0,0 +1,20 @@
+import { CargoManifest } from '../updaters/rust/common';
+import { Strategy, BuildUpdatesOptions } from '../strategy';
+import { Version } from '../version';
+import { Update } from '../update';
+export declare class Rust extends Strategy {
+    private packageManifest?;
+    private workspaceManifest?;
+    protected buildUpdates(options: BuildUpdatesOptions): Promise<Update[]>;
+    protected initialReleaseVersion(): Version;
+    getDefaultPackageName(): Promise<string | undefined>;
+    /**
+     * @returns the package's manifest, ie. `crates/foobar/Cargo.toml`
+     */
+    protected getPackageManifest(): Promise<CargoManifest | null>;
+    /**
+     * @returns the workspace's manifest, ie. `Cargo.toml` (top-level)
+     */
+    protected getWorkspaceManifest(): Promise<CargoManifest | null>;
+    protected getManifest(path: string): Promise<CargoManifest | null>;
+}

package/build/src/strategies/rust.js

@@ -0,0 +1,120 @@
+"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.Rust = void 0;
+// Generic
+const changelog_1 = require("../updaters/changelog");
+// Cargo.toml support
+const cargo_toml_1 = require("../updaters/rust/cargo-toml");
+const cargo_lock_1 = require("../updaters/rust/cargo-lock");
+const common_1 = require("../updaters/rust/common");
+const logger_1 = require("../util/logger");
+const strategy_1 = require("../strategy");
+const version_1 = require("../version");
+class Rust 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,
+            }),
+        });
+        const workspaceManifest = await this.getWorkspaceManifest();
+        const manifestPaths = [];
+        let lockPath;
+        if (workspaceManifest &&
+            workspaceManifest.workspace &&
+            workspaceManifest.workspace.members) {
+            const members = workspaceManifest.workspace.members;
+            logger_1.logger.info(`found workspace with ${members.length} members, upgrading all`);
+            for (const member of members) {
+                manifestPaths.push(`${member}/Cargo.toml`);
+            }
+            lockPath = 'Cargo.lock';
+        }
+        else {
+            const manifestPath = this.addPath('Cargo.toml');
+            logger_1.logger.info(`single crate found, updating ${manifestPath}`);
+            manifestPaths.push(manifestPath);
+            lockPath = this.addPath('Cargo.lock');
+        }
+        const versionsMap = new Map();
+        versionsMap.set(this.component || '', version);
+        for (const path of manifestPaths) {
+            updates.push({
+                path,
+                createIfMissing: false,
+                updater: new cargo_toml_1.CargoToml({
+                    version,
+                    versionsMap,
+                }),
+            });
+        }
+        updates.push({
+            path: lockPath,
+            createIfMissing: false,
+            updater: new cargo_lock_1.CargoLock({
+                version,
+                versionsMap,
+            }),
+        });
+        return updates;
+    }
+    initialReleaseVersion() {
+        return version_1.Version.parse('0.1.0');
+    }
+    async getDefaultPackageName() {
+        var _a;
+        const packageManifest = await this.getPackageManifest();
+        if (packageManifest) {
+            return (_a = packageManifest.package) === null || _a === void 0 ? void 0 : _a.name;
+        }
+        return undefined;
+    }
+    /**
+     * @returns the package's manifest, ie. `crates/foobar/Cargo.toml`
+     */
+    async getPackageManifest() {
+        if (this.packageManifest === undefined) {
+            this.packageManifest = await this.getManifest(this.addPath('Cargo.toml'));
+        }
+        return this.packageManifest;
+    }
+    /**
+     * @returns the workspace's manifest, ie. `Cargo.toml` (top-level)
+     */
+    async getWorkspaceManifest() {
+        if (this.workspaceManifest === undefined) {
+            this.workspaceManifest = await this.getManifest('Cargo.toml');
+        }
+        return this.workspaceManifest;
+    }
+    async getManifest(path) {
+        let content;
+        try {
+            content = await this.github.getFileContentsOnBranch(path, this.targetBranch);
+        }
+        catch (e) {
+            return null;
+        }
+        return common_1.parseCargoManifest(content.parsedContent);
+    }
+}
+exports.Rust = Rust;
+//# sourceMappingURL=rust.js.map

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

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

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

@@ -14,26 +14,30 @@
 // limitations under the License.
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Simple = void 0;
-const release_pr_1 = require("../release-pr");
 // Generic
 const changelog_1 = require("../updaters/changelog");
 // version.txt support
-const version_txt_1 = require("../updaters/version-txt");
-class Simple extends release_pr_1.ReleasePR {
-    async buildUpdates(changelogEntry, candidate, packageName) {
+const strategy_1 = require("../strategy");
+const default_1 = require("../updaters/default");
+class Simple 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,
-        }));
-        updates.push(new version_txt_1.VersionTxt({
+            createIfMissing: true,
+            updater: new changelog_1.Changelog({
+                version,
+                changelogEntry: options.changelogEntry,
+            }),
+        });
+        updates.push({
             path: this.addPath('version.txt'),
-            changelogEntry,
-            version: candidate.version,
-            packageName: packageName.name,
-        }));
+            createIfMissing: false,
+            updater: new default_1.DefaultUpdater({
+                version,
+            }),
+        });
         return updates;
     }
 }

package/build/src/strategies/terraform-module.d.ts

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

package/build/src/{releasers → strategies}/terraform-module.js

@@ -14,52 +14,58 @@
 // limitations under the License.
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TerraformModule = void 0;
-const release_pr_1 = require("../release-pr");
 // Generic
 const changelog_1 = require("../updaters/changelog");
 // Terraform specific.
 const readme_1 = require("../updaters/terraform/readme");
 const module_version_1 = require("../updaters/terraform/module-version");
-class TerraformModule extends release_pr_1.ReleasePR {
-    async buildUpdates(changelogEntry, candidate, packageName) {
+const strategy_1 = require("../strategy");
+const version_1 = require("../version");
+class TerraformModule 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,
+            }),
+        });
         // Update version in README to current candidate version.
         // A module may have submodules, so find all submodules.
-        const readmeFiles = await this.gh.findFilesByFilename('readme.md');
+        const readmeFiles = await this.github.findFilesByFilename('readme.md', this.path);
         readmeFiles.forEach(path => {
-            updates.push(new readme_1.ReadMe({
+            updates.push({
                 path: this.addPath(path),
-                changelogEntry,
-                version: candidate.version,
-                packageName: packageName.name,
-            }));
+                createIfMissing: false,
+                updater: new readme_1.ReadMe({
+                    version,
+                }),
+            });
         });
         // Update versions.tf to current candidate version.
         // A module may have submodules, so find all versions.tfand versions.tf.tmpl to update.
         const versionFiles = await Promise.all([
-            this.gh.findFilesByFilename('versions.tf'),
-            this.gh.findFilesByFilename('versions.tf.tmpl'),
+            this.github.findFilesByFilename('versions.tf', this.path),
+            this.github.findFilesByFilename('versions.tf.tmpl', this.path),
         ]).then(([v, vt]) => {
             return v.concat(vt);
         });
         versionFiles.forEach(path => {
-            updates.push(new module_version_1.ModuleVersion({
+            updates.push({
                 path: this.addPath(path),
-                changelogEntry,
-                version: candidate.version,
-                packageName: packageName.name,
-            }));
+                createIfMissing: false,
+                updater: new module_version_1.ModuleVersion({
+                    version,
+                }),
+            });
         });
         return updates;
     }
-    defaultInitialVersion() {
-        return '0.1.0';
+    initialReleaseVersion() {
+        return version_1.Version.parse('0.1.0');
     }
 }
 exports.TerraformModule = TerraformModule;

package/build/src/strategy.d.ts

@@ -0,0 +1,100 @@
+import { ReleasePullRequest } from './release-pull-request';
+import { Release } from './release';
+import { GitHub } from './github';
+import { Version, VersionsMap } from './version';
+import { Commit, ConventionalCommit } from './commit';
+import { VersioningStrategy } from './versioning-strategy';
+import { ChangelogNotes, ChangelogSection } from './changelog-notes';
+import { Update } from './update';
+import { Repository } from './repository';
+import { PullRequest } from './pull-request';
+import { TagName } from './util/tag-name';
+export interface BuildUpdatesOptions {
+    changelogEntry: string;
+    newVersion: Version;
+    versionsMap: VersionsMap;
+    latestVersion?: Version;
+}
+export interface StrategyOptions {
+    path?: string;
+    bumpMinorPreMajor?: boolean;
+    bumpPatchForMinorPreMajor?: boolean;
+    github: GitHub;
+    component?: string;
+    packageName?: string;
+    versioningStrategy?: VersioningStrategy;
+    targetBranch: string;
+    changelogPath?: string;
+    changelogSections?: ChangelogSection[];
+    commitPartial?: string;
+    headerPartial?: string;
+    mainTemplate?: string;
+    tagSeparator?: string;
+    skipGitHubRelease?: boolean;
+    releaseAs?: string;
+    changelogNotes?: ChangelogNotes;
+    includeComponentInTag?: boolean;
+}
+/**
+ * A strategy is responsible for determining which files are
+ * necessary to update in a release pull request.
+ */
+export declare abstract class Strategy {
+    readonly path: string;
+    protected github: GitHub;
+    readonly component?: string;
+    protected packageName?: string;
+    readonly versioningStrategy: VersioningStrategy;
+    protected targetBranch: string;
+    protected repository: Repository;
+    readonly changelogPath: string;
+    protected tagSeparator?: string;
+    private skipGitHubRelease;
+    private releaseAs?;
+    private includeComponentInTag;
+    protected changelogNotes: ChangelogNotes;
+    protected changelogSections?: ChangelogSection[];
+    constructor(options: StrategyOptions);
+    /**
+     * Specify the files necessary to update in a release pull request.
+     * @param {BuildUpdatesOptions} options
+     */
+    protected abstract buildUpdates(options: BuildUpdatesOptions): Promise<Update[]>;
+    getComponent(): Promise<string | undefined>;
+    getDefaultComponent(): Promise<string | undefined>;
+    getDefaultPackageName(): Promise<string | undefined>;
+    protected normalizeComponent(component: string | undefined): string;
+    /**
+     * Override this method to post process commits
+     * @param {ConventionalCommit[]} commits parsed commits
+     * @returns {ConventionalCommit[]} modified commits
+     */
+    protected postProcessCommits(commits: ConventionalCommit[]): ConventionalCommit[];
+    protected buildReleaseNotes(conventionalCommits: ConventionalCommit[], newVersion: Version, newVersionTag: TagName, latestRelease?: Release): Promise<string>;
+    /**
+     * Builds a candidate release pull request
+     * @param {Commit[]} commits Raw commits to consider for this release.
+     * @param {Release} latestRelease Optional. The last release for this
+     *   component if available.
+     * @param {boolean} draft Optional. Whether or not to create the pull
+     *   request as a draft. Defaults to `false`.
+     * @returns {ReleasePullRequest | undefined} The release pull request to
+     *   open for this path/component. Returns undefined if we should not
+     *   open a pull request.
+     */
+    buildReleasePullRequest(commits: Commit[], latestRelease?: Release, draft?: boolean, labels?: string[]): Promise<ReleasePullRequest | undefined>;
+    protected changelogEmpty(changelogEntry: string): boolean;
+    protected buildNewVersion(conventionalCommits: ConventionalCommit[], latestRelease?: Release): Promise<Version>;
+    protected buildVersionsMap(_conventionalCommits: ConventionalCommit[]): Promise<VersionsMap>;
+    /**
+     * Given a merged pull request, build the candidate release.
+     * @param {PullRequest} mergedPullRequest The merged release pull request.
+     * @returns {Release} The candidate release.
+     */
+    buildRelease(mergedPullRequest: PullRequest): Promise<Release | undefined>;
+    /**
+     * Override this to handle the initial version of a new library.
+     */
+    protected initialReleaseVersion(): Version;
+    protected addPath(file: string): string;
+}