release-please 13.0.0-candidate.2 → 13.0.0

package/build/src/updaters/rust/cargo-toml.js

@@ -55,7 +55,11 @@ class CargoToml extends default_1.DefaultUpdater {
                 }
                 const dep = deps[pkgName];
                 if (typeof dep === 'string' || typeof dep.path === 'undefined') {
-                    logger_1.logger.info(`skipping ${depKind}.${pkgName} in`);
+                    logger_1.logger.info(`skipping ${depKind}.${pkgName} (no path set)`);
+                    continue; // to next depKind
+                }
+                if (typeof dep.version === 'undefined') {
+                    logger_1.logger.info(`skipping ${depKind}.${pkgName} (no version set)`);
                     continue; // to next depKind
                 }
                 logger_1.logger.info(`updating ${depKind}.${pkgName} from ${dep.version} to ${pkgVersion}`);

package/build/src/util/branch-name.js

@@ -21,7 +21,13 @@ const version_1 = require("../version");
 // import {RELEASE_PLEASE} from '../constants';
 const RELEASE_PLEASE = 'release-please';
 function getAllResourceNames() {
-    return [AutoreleaseBranchName, ComponentBranchName, DefaultBranchName];
+    return [
+        AutoreleaseBranchName,
+        ComponentBranchName,
+        DefaultBranchName,
+        V12ComponentBranchName,
+        V12DefaultBranchName,
+    ];
 }
 class BranchName {
     constructor(_branchName) { }
@@ -41,10 +47,10 @@ class BranchName {
         return new AutoreleaseBranchName(`release-v${version}`);
     }
     static ofTargetBranch(targetBranch) {
-        return new DefaultBranchName(`${RELEASE_PLEASE}/branches/${targetBranch}`);
+        return new DefaultBranchName(`${RELEASE_PLEASE}--branches--${targetBranch}`);
     }
     static ofComponentTargetBranch(component, targetBranch) {
-        return new ComponentBranchName(`${RELEASE_PLEASE}/branches/${targetBranch}/components/${component}`);
+        return new ComponentBranchName(`${RELEASE_PLEASE}--branches--${targetBranch}--components--${component}`);
     }
     static matches(_branchName) {
         return false;
@@ -63,6 +69,11 @@ class BranchName {
     }
 }
 exports.BranchName = BranchName;
+/**
+ * This is the legacy branch pattern used by releasetool
+ *
+ * @see https://github.com/googleapis/releasetool
+ */
 const AUTORELEASE_PATTERN = /^release-?(?<component>[\w-.]*)?-v(?<version>[0-9].*)$/;
 class AutoreleaseBranchName extends BranchName {
     static matches(branchName) {
@@ -84,7 +95,54 @@ class AutoreleaseBranchName extends BranchName {
         return `release-v${(_b = this.version) === null || _b === void 0 ? void 0 : _b.toString()}`;
     }
 }
-const DEFAULT_PATTERN = `^${RELEASE_PLEASE}/branches/(?<branch>[^/]+)$`;
+/**
+ * This is a parsable branch pattern used by release-please v12.
+ * It has potential issues due to git treating `/` like directories.
+ * This should be removed at some point in the future.
+ *
+ * @see https://github.com/googleapis/release-please/issues/1024
+ */
+const V12_DEFAULT_PATTERN = `^${RELEASE_PLEASE}/branches/(?<branch>[^/]+)$`;
+class V12DefaultBranchName extends BranchName {
+    static matches(branchName) {
+        return !!branchName.match(V12_DEFAULT_PATTERN);
+    }
+    constructor(branchName) {
+        super(branchName);
+        const match = branchName.match(V12_DEFAULT_PATTERN);
+        if (match === null || match === void 0 ? void 0 : match.groups) {
+            this.targetBranch = match.groups['branch'];
+        }
+    }
+    toString() {
+        return `${RELEASE_PLEASE}/branches/${this.targetBranch}`;
+    }
+}
+/**
+ * This is a parsable branch pattern used by release-please v12.
+ * It has potential issues due to git treating `/` like directories.
+ * This should be removed at some point in the future.
+ *
+ * @see https://github.com/googleapis/release-please/issues/1024
+ */
+const V12_COMPONENT_PATTERN = `^${RELEASE_PLEASE}/branches/(?<branch>[^/]+)/components/(?<component>.+)$`;
+class V12ComponentBranchName extends BranchName {
+    static matches(branchName) {
+        return !!branchName.match(V12_COMPONENT_PATTERN);
+    }
+    constructor(branchName) {
+        super(branchName);
+        const match = branchName.match(V12_COMPONENT_PATTERN);
+        if (match === null || match === void 0 ? void 0 : match.groups) {
+            this.targetBranch = match.groups['branch'];
+            this.component = match.groups['component'];
+        }
+    }
+    toString() {
+        return `${RELEASE_PLEASE}/branches/${this.targetBranch}/components/${this.component}`;
+    }
+}
+const DEFAULT_PATTERN = `^${RELEASE_PLEASE}--branches--(?<branch>.+)$`;
 class DefaultBranchName extends BranchName {
     static matches(branchName) {
         return !!branchName.match(DEFAULT_PATTERN);
@@ -97,10 +155,10 @@ class DefaultBranchName extends BranchName {
         }
     }
     toString() {
-        return `${RELEASE_PLEASE}/branches/${this.targetBranch}`;
+        return `${RELEASE_PLEASE}--branches--${this.targetBranch}`;
     }
 }
-const COMPONENT_PATTERN = `^${RELEASE_PLEASE}/branches/(?<branch>[^/]+)/components/(?<component>.+)$`;
+const COMPONENT_PATTERN = `^${RELEASE_PLEASE}--branches--(?<branch>.+)--components--(?<component>.+)$`;
 class ComponentBranchName extends BranchName {
     static matches(branchName) {
         return !!branchName.match(COMPONENT_PATTERN);
@@ -114,7 +172,7 @@ class ComponentBranchName extends BranchName {
         }
     }
     toString() {
-        return `${RELEASE_PLEASE}/branches/${this.targetBranch}/components/${this.component}`;
+        return `${RELEASE_PLEASE}--branches--${this.targetBranch}--components--${this.component}`;
     }
 }
 //# sourceMappingURL=branch-name.js.map

package/build/src/util/commit-split.js

@@ -54,6 +54,9 @@ class CommitSplit {
     split(commits) {
         const splitCommits = {};
         commits.forEach(commit => {
+            if (commit.files === undefined) {
+                throw new Error(`Commit ${commit.sha} is missing files. Did you set "backfillFiles" to "true"?`);
+            }
             const dedupe = new Set();
             for (let i = 0; i < commit.files.length; i++) {
                 const file = commit.files[i];

package/build/src/util/pull-request-title.js

@@ -106,6 +106,7 @@ class PullRequestTitle {
             .replace('${scope}', scope)
             .replace('${component}', component)
             .replace('${version}', version.toString())
+            .replace('${branch}', this.targetBranch || '')
             .trim();
     }
 }

package/build/src/version.d.ts

@@ -1,11 +1,34 @@
+/**
+ * This data class is used to represent a SemVer version.
+ */
 export declare class Version {
-    major: number;
-    minor: number;
-    patch: number;
-    preRelease?: string;
-    build?: string;
+    readonly major: number;
+    readonly minor: number;
+    readonly patch: number;
+    readonly preRelease?: string;
+    readonly build?: string;
     constructor(major: number, minor: number, patch: number, preRelease?: string, build?: string);
+    /**
+     * Parse a version string into a data class.
+     *
+     * @param {string} versionString the input version string
+     * @returns {Version} the parsed version
+     * @throws {Error} if the version string cannot be parsed
+     */
     static parse(versionString: string): Version;
+    /**
+     * Comparator to other Versions to be used in sorting.
+     *
+     * @param {Version} other The other version to compare to
+     * @returns {number} -1 if this version is earlier, 0 if the versions
+     *   are the same, or 1 otherwise.
+     */
+    compare(other: Version): -1 | 0 | 1;
+    /**
+     * Returns a normalized string version of this version.
+     *
+     * @returns {string}
+     */
     toString(): string;
 }
 export declare type VersionsMap = Map<string, Version>;

package/build/src/version.js

@@ -14,7 +14,11 @@
 // limitations under the License.
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Version = void 0;
+const semver = require("semver");
 const VERSION_REGEX = /(?<major>\d+)\.(?<minor>\d+)\.(?<patch>\d+)(-(?<preRelease>[^+]+))?(\+(?<build>.*))?/;
+/**
+ * This data class is used to represent a SemVer version.
+ */
 class Version {
     constructor(major, minor, patch, preRelease, build) {
         this.major = major;
@@ -23,6 +27,13 @@ class Version {
         this.preRelease = preRelease;
         this.build = build;
     }
+    /**
+     * Parse a version string into a data class.
+     *
+     * @param {string} versionString the input version string
+     * @returns {Version} the parsed version
+     * @throws {Error} if the version string cannot be parsed
+     */
     static parse(versionString) {
         const match = versionString.match(VERSION_REGEX);
         if (!(match === null || match === void 0 ? void 0 : match.groups)) {
@@ -35,6 +46,21 @@ class Version {
         const build = match.groups.build;
         return new Version(major, minor, patch, preRelease, build);
     }
+    /**
+     * Comparator to other Versions to be used in sorting.
+     *
+     * @param {Version} other The other version to compare to
+     * @returns {number} -1 if this version is earlier, 0 if the versions
+     *   are the same, or 1 otherwise.
+     */
+    compare(other) {
+        return semver.compare(this.toString(), other.toString());
+    }
+    /**
+     * Returns a normalized string version of this version.
+     *
+     * @returns {string}
+     */
     toString() {
         const preReleasePart = this.preRelease ? `-${this.preRelease}` : '';
         const buildPart = this.build ? `+${this.build}` : '';

package/build/src/versioning-strategies/always-bump-patch.d.ts

@@ -2,6 +2,10 @@ import { Version } from '../version';
 import { ConventionalCommit } from '../commit';
 import { DefaultVersioningStrategy } from './default';
 import { VersionUpdater } from '../versioning-strategy';
+/**
+ * This VersioningStrategy always bumps the patch version. This
+ * strategy is useful for backport branches.
+ */
 export declare class AlwaysBumpPatch extends DefaultVersioningStrategy {
     determineReleaseType(_version: Version, _commits: ConventionalCommit[]): VersionUpdater;
 }

package/build/src/versioning-strategies/always-bump-patch.js

@@ -16,6 +16,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.AlwaysBumpPatch = void 0;
 const default_1 = require("./default");
 const versioning_strategy_1 = require("../versioning-strategy");
+/**
+ * This VersioningStrategy always bumps the patch version. This
+ * strategy is useful for backport branches.
+ */
 class AlwaysBumpPatch extends default_1.DefaultVersioningStrategy {
     determineReleaseType(_version, _commits) {
         return new versioning_strategy_1.PatchVersionUpdate();

package/build/src/versioning-strategies/default.d.ts

@@ -5,11 +5,42 @@ interface DefaultVersioningStrategyOptions {
     bumpMinorPreMajor?: boolean;
     bumpPatchForMinorPreMajor?: boolean;
 }
+/**
+ * This is the default VersioningStrategy for release-please. Breaking
+ * changes should bump the major, features should bump the minor, and other
+ * significant changes should bump the patch version.
+ */
 export declare class DefaultVersioningStrategy implements VersioningStrategy {
     readonly bumpMinorPreMajor: boolean;
     readonly bumpPatchForMinorPreMajor: boolean;
+    /**
+     * Create a new DefaultVersioningStrategy
+     * @param {DefaultVersioningStrategyOptions} options Configuration options
+     * @param {boolean} options.bumpMinorPreMajor If the current version is less than 1.0.0,
+     *   then bump the minor version for breaking changes
+     * @param {boolean} options.bumpPatchForMinorPreMajor If the current version is less than
+     *   1.0.0, then bump the patch version for features
+     */
     constructor(options?: DefaultVersioningStrategyOptions);
+    /**
+     * Given the current version of an artifact and a list of commits,
+     * return a VersionUpdater that knows how to bump the version.
+     *
+     * This is useful for chaining together versioning strategies.
+     *
+     * @param {Version} version The current version
+     * @param {ConventionalCommit[]} commits The list of commits to consider
+     * @returns {VersionUpdater} Updater for bumping the next version.
+     */
     determineReleaseType(version: Version, commits: ConventionalCommit[]): VersionUpdater;
+    /**
+     * Given the current version of an artifact and a list of commits,
+     * return the next version.
+     *
+     * @param {Version} version The current version
+     * @param {ConventionalCommit[]} commits The list of commits to consider
+     * @returns {Version} The next version
+     */
     bump(version: Version, commits: ConventionalCommit[]): Version;
 }
 export {};

package/build/src/versioning-strategies/default.js

@@ -16,11 +16,34 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.DefaultVersioningStrategy = void 0;
 const versioning_strategy_1 = require("../versioning-strategy");
 const version_1 = require("../version");
+/**
+ * This is the default VersioningStrategy for release-please. Breaking
+ * changes should bump the major, features should bump the minor, and other
+ * significant changes should bump the patch version.
+ */
 class DefaultVersioningStrategy {
+    /**
+     * Create a new DefaultVersioningStrategy
+     * @param {DefaultVersioningStrategyOptions} options Configuration options
+     * @param {boolean} options.bumpMinorPreMajor If the current version is less than 1.0.0,
+     *   then bump the minor version for breaking changes
+     * @param {boolean} options.bumpPatchForMinorPreMajor If the current version is less than
+     *   1.0.0, then bump the patch version for features
+     */
     constructor(options = {}) {
         this.bumpMinorPreMajor = options.bumpMinorPreMajor === true;
         this.bumpPatchForMinorPreMajor = options.bumpPatchForMinorPreMajor === true;
     }
+    /**
+     * Given the current version of an artifact and a list of commits,
+     * return a VersionUpdater that knows how to bump the version.
+     *
+     * This is useful for chaining together versioning strategies.
+     *
+     * @param {Version} version The current version
+     * @param {ConventionalCommit[]} commits The list of commits to consider
+     * @returns {VersionUpdater} Updater for bumping the next version.
+     */
     determineReleaseType(version, commits) {
         // iterate through list of commits and find biggest commit type
         let breaking = 0;
@@ -59,6 +82,14 @@ class DefaultVersioningStrategy {
         }
         return new versioning_strategy_1.PatchVersionUpdate();
     }
+    /**
+     * Given the current version of an artifact and a list of commits,
+     * return the next version.
+     *
+     * @param {Version} version The current version
+     * @param {ConventionalCommit[]} commits The list of commits to consider
+     * @returns {Version} The next version
+     */
     bump(version, commits) {
         return this.determineReleaseType(version, commits).bump(version);
     }

package/build/src/versioning-strategies/dependency-manifest.d.ts

@@ -2,6 +2,14 @@ import { Version } from '../version';
 import { ConventionalCommit } from '../commit';
 import { DefaultVersioningStrategy } from './default';
 import { VersionUpdater } from '../versioning-strategy';
+/**
+ * This VersioningStrategy looks at `deps` type commits and tries to
+ * mirror the semantic version bump for that dependency update. For
+ * example, an update to v2, would be treated as a major version bump.
+ *
+ * It also respects the default commit types and will pick the
+ * greatest version bump.
+ */
 export declare class DependencyManifest extends DefaultVersioningStrategy {
     determineReleaseType(version: Version, commits: ConventionalCommit[]): VersionUpdater;
 }

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

@@ -19,6 +19,14 @@ const semver = require("semver");
 const default_1 = require("./default");
 const versioning_strategy_1 = require("../versioning-strategy");
 const DEPENDENCY_UPDATE_REGEX = /^deps: update dependency (.*) to (v.*)(\s\(#\d+\))?$/m;
+/**
+ * This VersioningStrategy looks at `deps` type commits and tries to
+ * mirror the semantic version bump for that dependency update. For
+ * example, an update to v2, would be treated as a major version bump.
+ *
+ * It also respects the default commit types and will pick the
+ * greatest version bump.
+ */
 class DependencyManifest extends default_1.DefaultVersioningStrategy {
     determineReleaseType(version, commits) {
         const regularBump = super.determineReleaseType(version, commits);

package/build/src/versioning-strategies/java-add-snapshot.d.ts

@@ -1,6 +1,10 @@
 import { VersioningStrategy, VersionUpdater } from '../versioning-strategy';
 import { Version } from '../version';
 import { ConventionalCommit } from '../commit';
+/**
+ * This VersioningStrategy is used by Java releases to bump
+ * to the next snapshot version.
+ */
 export declare class JavaAddSnapshot implements VersioningStrategy {
     strategy: VersioningStrategy;
     constructor(strategy: VersioningStrategy);

package/build/src/versioning-strategies/java-add-snapshot.js

@@ -14,6 +14,7 @@
 // limitations under the License.
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.JavaAddSnapshot = void 0;
+const version_1 = require("../version");
 const fakeCommit = {
     message: 'fix: fake fix',
     type: 'fix',
@@ -27,17 +28,17 @@ const fakeCommit = {
 };
 class AddSnapshotVersionUpdate {
     constructor(strategy) {
-        this.name = 'java-snapshot';
         this.strategy = strategy;
     }
     bump(version) {
         const nextPatch = this.strategy.bump(version, [fakeCommit]);
-        nextPatch.preRelease = nextPatch.preRelease
-            ? `${nextPatch.preRelease}-SNAPSHOT`
-            : 'SNAPSHOT';
-        return nextPatch;
+        return new version_1.Version(nextPatch.major, nextPatch.minor, nextPatch.patch, nextPatch.preRelease ? `${nextPatch.preRelease}-SNAPSHOT` : 'SNAPSHOT', nextPatch.build);
     }
 }
+/**
+ * This VersioningStrategy is used by Java releases to bump
+ * to the next snapshot version.
+ */
 class JavaAddSnapshot {
     constructor(strategy) {
         this.strategy = strategy;

package/build/src/versioning-strategies/java-snapshot.d.ts

@@ -1,6 +1,10 @@
 import { VersioningStrategy, VersionUpdater } from '../versioning-strategy';
 import { Version } from '../version';
 import { ConventionalCommit } from '../commit';
+/**
+ * This VersioningStrategy is used by Java releases to bump
+ * to the next non-snapshot version.
+ */
 export declare class JavaSnapshot implements VersioningStrategy {
     strategy: VersioningStrategy;
     constructor(strategy: VersioningStrategy);

package/build/src/versioning-strategies/java-snapshot.js

@@ -28,7 +28,6 @@ const fakeCommit = {
 };
 class RemoveSnapshotVersionUpdate {
     constructor(parent) {
-        this.name = 'remove-snapshot';
         this.parent = parent;
     }
     bump(version) {
@@ -40,6 +39,10 @@ class RemoveSnapshotVersionUpdate {
             : undefined, version.build);
     }
 }
+/**
+ * This VersioningStrategy is used by Java releases to bump
+ * to the next non-snapshot version.
+ */
 class JavaSnapshot {
     constructor(strategy) {
         this.strategy = strategy;

package/build/src/versioning-strategies/service-pack.d.ts

@@ -2,6 +2,11 @@ import { Version } from '../version';
 import { DefaultVersioningStrategy } from './default';
 import { ConventionalCommit } from '../commit';
 import { VersionUpdater } from '../versioning-strategy';
+/**
+ * This VersioningStrategy is used for "service pack" versioning. In this
+ * strategy, we use the pre-release field with a pattern of `sp-\d+` where
+ * the number is an auto-incrementing integer starting with 1.
+ */
 export declare class ServicePackVersioningStrategy extends DefaultVersioningStrategy {
     determineReleaseType(_version: Version, _commits: ConventionalCommit[]): VersionUpdater;
 }

package/build/src/versioning-strategies/service-pack.js

@@ -17,10 +17,12 @@ exports.ServicePackVersioningStrategy = void 0;
 const version_1 = require("../version");
 const default_1 = require("./default");
 const SERVICE_PACK_PATTERN = /sp\.(\d+)/;
+/**
+ * This version updater knows how to bump from a non-service pack
+ * version to a service pack version and increment the service
+ * pack number in subsequent releases.
+ */
 class ServicePackVersionUpdate {
-    constructor() {
-        this.name = 'service-pack';
-    }
     bump(version) {
         var _a;
         const match = (_a = version.preRelease) === null || _a === void 0 ? void 0 : _a.match(SERVICE_PACK_PATTERN);
@@ -31,6 +33,11 @@ class ServicePackVersionUpdate {
         return new version_1.Version(version.major, version.minor, version.patch, 'sp.1', version.build);
     }
 }
+/**
+ * This VersioningStrategy is used for "service pack" versioning. In this
+ * strategy, we use the pre-release field with a pattern of `sp-\d+` where
+ * the number is an auto-incrementing integer starting with 1.
+ */
 class ServicePackVersioningStrategy extends default_1.DefaultVersioningStrategy {
     determineReleaseType(_version, _commits) {
         return new ServicePackVersionUpdate();

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

@@ -1,28 +1,90 @@
 import { Version } from './version';
 import { ConventionalCommit } from './commit';
+/**
+ * An interface for updating a version.
+ */
 export interface VersionUpdater {
+    /**
+     * Returns the new bumped version
+     *
+     * @param {Version} version The current version
+     * @returns {Version} The bumped version
+     */
     bump(version: Version): Version;
-    name: string;
 }
+/**
+ * This VersionUpdater performs a SemVer major version bump.
+ */
 export declare class MajorVersionUpdate implements VersionUpdater {
-    name: string;
+    /**
+     * Returns the new bumped version
+     *
+     * @param {Version} version The current version
+     * @returns {Version} The bumped version
+     */
     bump(version: Version): Version;
 }
+/**
+ * This VersionUpdater performs a SemVer minor version bump.
+ */
 export declare class MinorVersionUpdate implements VersionUpdater {
-    name: string;
+    /**
+     * Returns the new bumped version
+     *
+     * @param {Version} version The current version
+     * @returns {Version} The bumped version
+     */
     bump(version: Version): Version;
 }
+/**
+ * This VersionUpdater performs a SemVer patch version bump.
+ */
 export declare class PatchVersionUpdate implements VersionUpdater {
-    name: string;
+    /**
+     * Returns the new bumped version
+     *
+     * @param {Version} version The current version
+     * @returns {Version} The bumped version
+     */
     bump(version: Version): Version;
 }
+/**
+ * This VersionUpdater sets the version to a specific version.
+ */
 export declare class CustomVersionUpdate implements VersionUpdater {
-    name: string;
     private versionString;
     constructor(versionString: string);
+    /**
+     * Returns the new bumped version. This version is specified
+     * at initialization.
+     *
+     * @param {Version} version The current version
+     * @returns {Version} The bumped version
+     */
     bump(_version: Version): Version;
 }
+/**
+ * Implement this interface to create a new versioning scheme.
+ */
 export interface VersioningStrategy {
+    /**
+     * Given the current version of an artifact and a list of commits,
+     * return the next version.
+     *
+     * @param {Version} version The current version
+     * @param {ConventionalCommit[]} commits The list of commits to consider
+     * @returns {Version} The next version
+     */
     bump(version: Version, commits: ConventionalCommit[]): Version;
+    /**
+     * Given the current version of an artifact and a list of commits,
+     * return a VersionUpdater that knows how to bump the version.
+     *
+     * This is useful for chaining together versioning strategies.
+     *
+     * @param {Version} version The current version
+     * @param {ConventionalCommit[]} commits The list of commits to consider
+     * @returns {VersionUpdater} Updater for bumping the next version.
+     */
     determineReleaseType(version: Version, commits: ConventionalCommit[]): VersionUpdater;
 }