release-please 13.0.0-candidate.3 → 13.0.1

package/build/src/release-pull-request.d.ts

@@ -3,11 +3,11 @@ import { Version } from './version';
 import { PullRequestBody } from './util/pull-request-body';
 import { PullRequestTitle } from './util/pull-request-title';
 export interface ReleasePullRequest {
-    title: PullRequestTitle;
-    body: PullRequestBody;
+    readonly title: PullRequestTitle;
+    readonly body: PullRequestBody;
+    readonly labels: string[];
+    readonly headRefName: string;
+    readonly version?: Version;
+    readonly draft: boolean;
     updates: Update[];
-    labels: string[];
-    headRefName: string;
-    version?: Version;
-    draft: boolean;
 }

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

@@ -0,0 +1,108 @@
+import { Strategy } from '../strategy';
+import { GitHub } from '../github';
+import { VersioningStrategy } from '../versioning-strategy';
+import { Repository } from '../repository';
+import { ChangelogNotes, ChangelogSection } from '../changelog-notes';
+import { Update } from '../update';
+import { ConventionalCommit, Commit } from '../commit';
+import { Version, VersionsMap } from '../version';
+import { TagName } from '../util/tag-name';
+import { Release } from '../release';
+import { ReleasePullRequest } from '../release-pull-request';
+import { PullRequest } from '../pull-request';
+export interface BuildUpdatesOptions {
+    changelogEntry: string;
+    newVersion: Version;
+    versionsMap: VersionsMap;
+    latestVersion?: Version;
+}
+export interface BaseStrategyOptions {
+    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;
+    pullRequestTitlePattern?: string;
+}
+/**
+ * A strategy is responsible for determining which files are
+ * necessary to update in a release pull request.
+ */
+export declare abstract class BaseStrategy implements Strategy {
+    readonly path: string;
+    protected github: GitHub;
+    protected component?: string;
+    protected packageName?: string;
+    readonly versioningStrategy: VersioningStrategy;
+    protected targetBranch: string;
+    protected repository: Repository;
+    protected changelogPath: string;
+    protected tagSeparator?: string;
+    private skipGitHubRelease;
+    private releaseAs?;
+    private includeComponentInTag;
+    private pullRequestTitlePattern?;
+    readonly changelogNotes: ChangelogNotes;
+    protected changelogSections?: ChangelogSection[];
+    constructor(options: BaseStrategyOptions);
+    /**
+     * Specify the files necessary to update in a release pull request.
+     * @param {BuildUpdatesOptions} options
+     */
+    protected abstract buildUpdates(options: BuildUpdatesOptions): Promise<Update[]>;
+    /**
+     * Return the component for this strategy. This may be a computed field.
+     * @returns {string}
+     */
+    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 updateVersionsMap(versionsMap: VersionsMap, conventionalCommits: ConventionalCommit[]): Promise<VersionsMap>;
+    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;
+}

package/build/src/strategies/base.js

@@ -0,0 +1,253 @@
+"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.BaseStrategy = void 0;
+const manifest_1 = require("../manifest");
+const default_1 = require("../versioning-strategies/default");
+const default_2 = require("../changelog-notes/default");
+const commit_1 = require("../commit");
+const version_1 = require("../version");
+const tag_name_1 = require("../util/tag-name");
+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_CHANGELOG_PATH = 'CHANGELOG.md';
+/**
+ * A strategy is responsible for determining which files are
+ * necessary to update in a release pull request.
+ */
+class BaseStrategy {
+    constructor(options) {
+        var _a;
+        this.path = options.path || manifest_1.ROOT_PROJECT_PATH;
+        this.github = options.github;
+        this.packageName = options.packageName;
+        this.component =
+            options.component || this.normalizeComponent(this.packageName);
+        this.versioningStrategy =
+            options.versioningStrategy || new default_1.DefaultVersioningStrategy({});
+        this.targetBranch = options.targetBranch;
+        this.repository = options.github.repository;
+        this.changelogPath = options.changelogPath || DEFAULT_CHANGELOG_PATH;
+        this.changelogSections = options.changelogSections;
+        this.tagSeparator = options.tagSeparator;
+        this.skipGitHubRelease = options.skipGitHubRelease || false;
+        this.releaseAs = options.releaseAs;
+        this.changelogNotes =
+            options.changelogNotes || new default_2.DefaultChangelogNotes(options);
+        this.includeComponentInTag = (_a = options.includeComponentInTag) !== null && _a !== void 0 ? _a : true;
+        this.pullRequestTitlePattern = options.pullRequestTitlePattern;
+    }
+    /**
+     * Return the component for this strategy. This may be a computed field.
+     * @returns {string}
+     */
+    async getComponent() {
+        if (!this.includeComponentInTag) {
+            return '';
+        }
+        return this.component || (await this.getDefaultComponent());
+    }
+    async getDefaultComponent() {
+        return this.normalizeComponent(await this.getDefaultPackageName());
+    }
+    async getDefaultPackageName() {
+        return '';
+    }
+    normalizeComponent(component) {
+        if (!component) {
+            return '';
+        }
+        return component;
+    }
+    /**
+     * Override this method to post process commits
+     * @param {ConventionalCommit[]} commits parsed commits
+     * @returns {ConventionalCommit[]} modified commits
+     */
+    postProcessCommits(commits) {
+        return commits;
+    }
+    async buildReleaseNotes(conventionalCommits, newVersion, newVersionTag, latestRelease) {
+        var _a;
+        return await this.changelogNotes.buildNotes(conventionalCommits, {
+            owner: this.repository.owner,
+            repository: this.repository.repo,
+            version: newVersion.toString(),
+            previousTag: (_a = latestRelease === null || latestRelease === void 0 ? void 0 : latestRelease.tag) === null || _a === void 0 ? void 0 : _a.toString(),
+            currentTag: newVersionTag.toString(),
+            targetBranch: this.targetBranch,
+            changelogSections: this.changelogSections,
+        });
+    }
+    /**
+     * 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.
+     */
+    async buildReleasePullRequest(commits, latestRelease, draft, labels = []) {
+        const conventionalCommits = this.postProcessCommits(commit_1.parseConventionalCommits(commits));
+        const newVersion = await this.buildNewVersion(conventionalCommits, latestRelease);
+        const versionsMap = await this.updateVersionsMap(await this.buildVersionsMap(conventionalCommits), conventionalCommits);
+        const component = await this.getComponent();
+        logger_1.logger.debug('component:', component);
+        const newVersionTag = new tag_name_1.TagName(newVersion, this.includeComponentInTag ? component : undefined, this.tagSeparator);
+        logger_1.logger.warn('pull request title pattern:', this.pullRequestTitlePattern);
+        const pullRequestTitle = pull_request_title_1.PullRequestTitle.ofComponentTargetBranchVersion(component || '', this.targetBranch, newVersion, this.pullRequestTitlePattern);
+        const branchName = component
+            ? branch_name_1.BranchName.ofComponentTargetBranch(component, this.targetBranch)
+            : branch_name_1.BranchName.ofTargetBranch(this.targetBranch);
+        const releaseNotesBody = await this.buildReleaseNotes(conventionalCommits, newVersion, newVersionTag, latestRelease);
+        if (this.changelogEmpty(releaseNotesBody)) {
+            logger_1.logger.info(`No user facing commits found since ${latestRelease ? latestRelease.sha : 'beginning of time'} - skipping`);
+            return undefined;
+        }
+        const updates = await this.buildUpdates({
+            changelogEntry: releaseNotesBody,
+            newVersion,
+            versionsMap,
+            latestVersion: latestRelease === null || latestRelease === void 0 ? void 0 : latestRelease.tag.version,
+        });
+        const pullRequestBody = new pull_request_body_1.PullRequestBody([
+            {
+                component,
+                version: newVersion,
+                notes: releaseNotesBody,
+            },
+        ]);
+        return {
+            title: pullRequestTitle,
+            body: pullRequestBody,
+            updates,
+            labels,
+            headRefName: branchName.toString(),
+            version: newVersion,
+            draft: draft !== null && draft !== void 0 ? draft : false,
+        };
+    }
+    changelogEmpty(changelogEntry) {
+        return changelogEntry.split('\n').length <= 1;
+    }
+    async updateVersionsMap(versionsMap, conventionalCommits) {
+        for (const versionKey of versionsMap.keys()) {
+            const version = versionsMap.get(versionKey);
+            if (!version) {
+                logger_1.logger.warn(`didn't find version for ${versionKey}`);
+                continue;
+            }
+            const newVersion = await this.versioningStrategy.bump(version, conventionalCommits);
+            versionsMap.set(versionKey, newVersion);
+        }
+        return versionsMap;
+    }
+    async buildNewVersion(conventionalCommits, latestRelease) {
+        if (this.releaseAs) {
+            logger_1.logger.warn(`Setting version for ${this.path} from release-as configuration`);
+            return version_1.Version.parse(this.releaseAs);
+        }
+        else if (latestRelease) {
+            return await this.versioningStrategy.bump(latestRelease.tag.version, conventionalCommits);
+        }
+        else {
+            return this.initialReleaseVersion();
+        }
+    }
+    async buildVersionsMap(_conventionalCommits) {
+        return new Map();
+    }
+    /**
+     * Given a merged pull request, build the candidate release.
+     * @param {PullRequest} mergedPullRequest The merged release pull request.
+     * @returns {Release} The candidate release.
+     */
+    async buildRelease(mergedPullRequest) {
+        if (this.skipGitHubRelease) {
+            logger_1.logger.info('Release skipped from strategy config');
+            return;
+        }
+        if (!mergedPullRequest.sha) {
+            logger_1.logger.error('Pull request should have been merged');
+            return;
+        }
+        const pullRequestTitle = pull_request_title_1.PullRequestTitle.parse(mergedPullRequest.title, this.pullRequestTitlePattern) ||
+            pull_request_title_1.PullRequestTitle.parse(mergedPullRequest.title, manifest_1.MANIFEST_PULL_REQUEST_TITLE_PATTERN);
+        if (!pullRequestTitle) {
+            logger_1.logger.error(`Bad pull request title: '${mergedPullRequest.title}'`);
+            return;
+        }
+        const branchName = branch_name_1.BranchName.parse(mergedPullRequest.headBranchName);
+        if (!branchName) {
+            logger_1.logger.error(`Bad branch name: ${mergedPullRequest.headBranchName}`);
+            return;
+        }
+        const pullRequestBody = pull_request_body_1.PullRequestBody.parse(mergedPullRequest.body);
+        if (!pullRequestBody) {
+            logger_1.logger.error('Could not parse pull request body as a release PR');
+            return;
+        }
+        const component = await this.getComponent();
+        logger_1.logger.info('component:', component);
+        const releaseData = pullRequestBody.releaseData.length === 1 &&
+            !pullRequestBody.releaseData[0].component
+            ? pullRequestBody.releaseData[0]
+            : pullRequestBody.releaseData.find(releaseData => {
+                return (this.normalizeComponent(releaseData.component) ===
+                    this.normalizeComponent(component));
+            });
+        const notes = releaseData === null || releaseData === void 0 ? void 0 : releaseData.notes;
+        if (notes === undefined) {
+            logger_1.logger.warn('Failed to find release notes');
+        }
+        const version = pullRequestTitle.getVersion() || (releaseData === null || releaseData === void 0 ? void 0 : releaseData.version);
+        if (!version) {
+            logger_1.logger.error('Pull request should have included version');
+            return;
+        }
+        const tag = new tag_name_1.TagName(version, this.includeComponentInTag ? component : undefined, this.tagSeparator);
+        return {
+            tag,
+            notes: notes || '',
+            sha: mergedPullRequest.sha,
+        };
+    }
+    /**
+     * Override this to handle the initial version of a new library.
+     */
+    initialReleaseVersion() {
+        return version_1.Version.parse('1.0.0');
+    }
+    addPath(file) {
+        if (this.path === manifest_1.ROOT_PROJECT_PATH) {
+            return file;
+        }
+        file = file.replace(/^[/\\]/, '');
+        if (this.path === undefined) {
+            return file;
+        }
+        else {
+            const path = this.path.replace(/[/\\]$/, '');
+            return `${path}/${file}`;
+        }
+    }
+}
+exports.BaseStrategy = BaseStrategy;
+//# sourceMappingURL=base.js.map

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

@@ -1,6 +1,6 @@
-import { Strategy, BuildUpdatesOptions } from '../strategy';
+import { BaseStrategy, BuildUpdatesOptions } from './base';
 import { Update } from '../update';
-export declare class Dart extends Strategy {
+export declare class Dart extends BaseStrategy {
     private pubspecYmlContents?;
     protected buildUpdates(options: BuildUpdatesOptions): Promise<Update[]>;
     getDefaultPackageName(): Promise<string | undefined>;

package/build/src/strategies/dart.js

@@ -19,8 +19,8 @@ const changelog_1 = require("../updaters/changelog");
 const yaml = require("js-yaml");
 // pubspec
 const pubspec_yaml_1 = require("../updaters/dart/pubspec-yaml");
-const strategy_1 = require("../strategy");
-class Dart extends strategy_1.Strategy {
+const base_1 = require("./base");
+class Dart extends base_1.BaseStrategy {
     async buildUpdates(options) {
         const updates = [];
         const version = options.newVersion;

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

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

package/build/src/strategies/elixir.js

@@ -18,8 +18,8 @@ exports.Elixir = void 0;
 const changelog_1 = require("../updaters/changelog");
 // mix.exs support
 const elixir_mix_exs_1 = require("../updaters/elixir/elixir-mix-exs");
-const strategy_1 = require("../strategy");
-class Elixir extends strategy_1.Strategy {
+const base_1 = require("./base");
+class Elixir extends base_1.BaseStrategy {
     async buildUpdates(options) {
         const updates = [];
         const version = options.newVersion;

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

@@ -1,11 +1,11 @@
-import { Strategy, BuildUpdatesOptions, StrategyOptions } from '../strategy';
+import { BaseStrategy, BuildUpdatesOptions, BaseStrategyOptions } from './base';
 import { Update } from '../update';
 import { ConventionalCommit } from '../commit';
 import { Version } from '../version';
 import { TagName } from '../util/tag-name';
 import { Release } from '../release';
-export declare class GoYoshi extends Strategy {
-    constructor(options: StrategyOptions);
+export declare class GoYoshi extends BaseStrategy {
+    constructor(options: BaseStrategyOptions);
     protected buildUpdates(options: BuildUpdatesOptions): Promise<Update[]>;
     protected postProcessCommits(commits: ConventionalCommit[]): ConventionalCommit[];
     protected buildReleaseNotes(conventionalCommits: ConventionalCommit[], newVersion: Version, newVersionTag: TagName, latestRelease?: Release): Promise<string>;

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

@@ -14,9 +14,10 @@
 // limitations under the License.
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GoYoshi = void 0;
-const strategy_1 = require("../strategy");
+const base_1 = require("./base");
 const changelog_1 = require("../updaters/changelog");
 const version_1 = require("../version");
+const version_go_1 = require("../updaters/go/version-go");
 // 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([
@@ -32,7 +33,7 @@ const IGNORED_SUB_MODULES = new Set([
 ]);
 const REGEN_PR_REGEX = /.*auto-regenerate.*/;
 const REGEN_ISSUE_REGEX = /(?<prefix>.*)\(#(?<pr>.*)\)(\n|$)/;
-class GoYoshi extends strategy_1.Strategy {
+class GoYoshi extends base_1.BaseStrategy {
     constructor(options) {
         var _a;
         options.changelogPath = (_a = options.changelogPath) !== null && _a !== void 0 ? _a : 'CHANGES.md';
@@ -49,6 +50,13 @@ class GoYoshi extends strategy_1.Strategy {
                 changelogEntry: options.changelogEntry,
             }),
         });
+        updates.push({
+            path: this.addPath('internal/version.go'),
+            createIfMissing: false,
+            updater: new version_go_1.VersionGo({
+                version,
+            }),
+        });
         return updates;
     }
     postProcessCommits(commits) {

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

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

package/build/src/strategies/go.js

@@ -16,8 +16,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Go = void 0;
 // Generic
 const changelog_1 = require("../updaters/changelog");
-const strategy_1 = require("../strategy");
-class Go extends strategy_1.Strategy {
+const base_1 = require("./base");
+class Go extends base_1.BaseStrategy {
     async buildUpdates(options) {
         const updates = [];
         const version = options.newVersion;

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

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

package/build/src/strategies/helm.js

@@ -19,8 +19,8 @@ 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 {
+const base_1 = require("./base");
+class Helm extends base_1.BaseStrategy {
     async buildUpdates(options) {
         const updates = [];
         const version = options.newVersion;

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

@@ -1,14 +1,14 @@
 import { Update } from '../update';
 import { Version, VersionsMap } from '../version';
-import { Strategy, StrategyOptions, BuildUpdatesOptions } from '../strategy';
+import { BaseStrategy, BuildUpdatesOptions, BaseStrategyOptions } from './base';
 import { GitHubFileContents } from '../github';
-import { Commit } from '../commit';
+import { Commit, ConventionalCommit } from '../commit';
 import { Release } from '../release';
 import { ReleasePullRequest } from '../release-pull-request';
-interface JavaStrategyOptions extends StrategyOptions {
+interface JavaStrategyOptions extends BaseStrategyOptions {
     extraFiles?: string[];
 }
-export declare class JavaYoshi extends Strategy {
+export declare class JavaYoshi extends BaseStrategy {
     readonly extraFiles: string[];
     private versionsContent?;
     private snapshotVersioning;
@@ -19,6 +19,7 @@ export declare class JavaYoshi extends Strategy {
     protected buildVersionsMap(): Promise<VersionsMap>;
     protected getVersionsContent(): Promise<GitHubFileContents>;
     protected buildUpdates(options: BuildUpdatesOptions): Promise<Update[]>;
+    protected updateVersionsMap(versionsMap: VersionsMap, conventionalCommits: ConventionalCommit[]): Promise<VersionsMap>;
     protected initialReleaseVersion(): Version;
 }
 export {};

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

@@ -17,7 +17,7 @@ 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 base_1 = require("./base");
 const changelog_1 = require("../updaters/changelog");
 const java_snapshot_1 = require("../versioning-strategies/java-snapshot");
 const errors_1 = require("../errors");
@@ -41,7 +41,7 @@ const CHANGELOG_SECTIONS = [
     { type: 'build', section: 'Build System', hidden: true },
     { type: 'ci', section: 'Continuous Integration', hidden: true },
 ];
-class JavaYoshi extends strategy_1.Strategy {
+class JavaYoshi extends base_1.BaseStrategy {
     constructor(options) {
         var _a;
         options.changelogSections = (_a = options.changelogSections) !== null && _a !== void 0 ? _a : CHANGELOG_SECTIONS;
@@ -195,9 +195,65 @@ class JavaYoshi extends strategy_1.Strategy {
         });
         return updates;
     }
+    async updateVersionsMap(versionsMap, conventionalCommits) {
+        let isPromotion = false;
+        const modifiedCommits = [];
+        for (const commit of conventionalCommits) {
+            if (isPromotionCommit(commit)) {
+                isPromotion = true;
+                modifiedCommits.push({
+                    ...commit,
+                    notes: commit.notes.filter(note => !isPromotionNote(note)),
+                });
+            }
+            else {
+                modifiedCommits.push(commit);
+            }
+        }
+        for (const versionKey of versionsMap.keys()) {
+            const version = versionsMap.get(versionKey);
+            if (!version) {
+                logger_1.logger.warn(`didn't find version for ${versionKey}`);
+                continue;
+            }
+            if (isPromotion && isStableArtifact(versionKey)) {
+                versionsMap.set(versionKey, version_1.Version.parse('1.0.0'));
+            }
+            else {
+                const newVersion = await this.versioningStrategy.bump(version, modifiedCommits);
+                versionsMap.set(versionKey, newVersion);
+            }
+        }
+        return versionsMap;
+    }
     initialReleaseVersion() {
         return version_1.Version.parse('0.1.0');
     }
 }
 exports.JavaYoshi = JavaYoshi;
+const VERSIONED_ARTIFACT_REGEX = /^.*-(v\d+[^-]*)$/;
+const VERSION_REGEX = /^v\d+(.*)$/;
+/**
+ * Returns true if the artifact should be considered stable
+ * @param artifact name of the artifact to check
+ */
+function isStableArtifact(artifact) {
+    const match = artifact.match(VERSIONED_ARTIFACT_REGEX);
+    if (!match) {
+        // The artifact does not have a version qualifier at the end
+        return true;
+    }
+    const versionMatch = match[1].match(VERSION_REGEX);
+    if (versionMatch && versionMatch[1]) {
+        // The version is not stable (probably alpha/beta/rc)
+        return false;
+    }
+    return true;
+}
+function isPromotionCommit(commit) {
+    return commit.notes.some(isPromotionNote);
+}
+function isPromotionNote(note) {
+    return note.title === 'RELEASE AS' && note.text === '1.0.0';
+}
 //# sourceMappingURL=java-yoshi.js.map

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

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

package/build/src/strategies/krm-blueprint.js

@@ -18,11 +18,11 @@ exports.KRMBlueprint = void 0;
 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 base_1 = require("./base");
 const version_1 = require("../version");
 const KRMBlueprintAttribAnnotation = 'cnrm.cloud.google.com/blueprint';
 const hasKRMBlueprintAttrib = (content) => content.includes(KRMBlueprintAttribAnnotation);
-class KRMBlueprint extends strategy_1.Strategy {
+class KRMBlueprint extends base_1.BaseStrategy {
     async buildUpdates(options) {
         const updates = [];
         const version = options.newVersion;
@@ -39,7 +39,7 @@ class KRMBlueprint extends strategy_1.Strategy {
             versionsMap.set('previousVersion', options.latestVersion);
         }
         // Update version in all yaml files with attribution annotation
-        const yamlPaths = await this.github.findFilesByExtension('yaml', this.path);
+        const yamlPaths = await this.github.findFilesByExtensionAndRef('yaml', this.targetBranch, this.path);
         for (const yamlPath of yamlPaths) {
             const contents = await this.github.getFileContents(this.addPath(yamlPath));
             if (hasKRMBlueprintAttrib(contents.parsedContent)) {