release-please 15.1.1 → 15.2.0

package/CHANGELOG.md

@@ -4,6 +4,23 @@
 
 [1]: https://www.npmjs.com/package/release-please?activeTab=versions
 
+## [15.2.0](https://github.com/googleapis/release-please/compare/v15.1.2...v15.2.0) (2023-01-23)
+
+
+### Features
+
+* **cli:** Add ability to dynamically load release-please plugin ([#1811](https://github.com/googleapis/release-please/issues/1811)) ([609383b](https://github.com/googleapis/release-please/commit/609383be5a05bb0107b489314b4bcd7615ddafd9))
+* Export Strategy interface so external packages can implement ([609383b](https://github.com/googleapis/release-please/commit/609383be5a05bb0107b489314b4bcd7615ddafd9))
+* Introduce ChangelogJson updater ([#1808](https://github.com/googleapis/release-please/issues/1808)) ([fe3a979](https://github.com/googleapis/release-please/commit/fe3a979a1c228610612aa2d6c303d408be956e2e))
+* Introduce JavaYoshiMonoRepo strategy ([#1810](https://github.com/googleapis/release-please/issues/1810)) ([2d14307](https://github.com/googleapis/release-please/commit/2d143077a545b92e1d9de923ab81ae1e12b7a468))
+
+## [15.1.2](https://github.com/googleapis/release-please/compare/v15.1.1...v15.1.2) (2023-01-17)
+
+
+### Bug Fixes
+
+* **ruby:** Gemfile.lock should not update when gem name is empty ([#1805](https://github.com/googleapis/release-please/issues/1805)) ([b54d499](https://github.com/googleapis/release-please/commit/b54d499a6b38e13175402fbd7eb7be75094d5014))
+
 ## [15.1.1](https://github.com/googleapis/release-please/compare/v15.1.0...v15.1.1) (2023-01-06)
 
 

package/build/src/bin/release-please.d.ts

@@ -6,27 +6,12 @@ interface ErrorObject {
     message: string;
     stack: string;
 }
-interface GitHubArgs {
-    dryRun?: boolean;
-    trace?: boolean;
-    repoUrl?: string;
-    token?: string;
-    apiUrl?: string;
-    graphqlUrl?: string;
-    fork?: boolean;
-    defaultBranch?: string;
-    targetBranch?: string;
-}
-interface ManifestArgs {
-    configFile?: string;
-    manifestFile?: string;
-}
-interface DebugConfigArgs extends GitHubArgs, ManifestArgs {
-}
-export declare const parser: yargs.Argv<yargs.Omit<DebugConfigArgs & {
+export declare const parser: yargs.Argv<{
     debug: boolean;
-}, "trace"> & {
+} & {
     trace: boolean;
+} & {
+    plugin: (string | number)[] | never[];
 }>;
 interface HandleError {
     (err: ErrorObject): void;

package/build/src/bin/release-please.js

@@ -570,6 +570,28 @@ exports.parser = yargs
     else if (argv.debug) {
         (0, logger_1.setLogger)(new logger_1.CheckpointLogger(true));
     }
+})
+    .option('plugin', {
+    describe: 'load plugin named release-please-<plugin-name>',
+    type: 'array',
+    default: [],
+})
+    .middleware(argv => {
+    for (const pluginName of argv.plugin) {
+        console.log(`requiring plugin: ${pluginName}`);
+        try {
+            const plugin = require(pluginName.toString());
+            if (plugin === null || plugin === void 0 ? void 0 : plugin.init) {
+                console.log(`loading plugin: ${pluginName}`);
+            }
+            else {
+                console.warn(`plugin: ${pluginName} did not have an init() function.`);
+            }
+        }
+        catch (e) {
+            console.warn(`failed to require plugin: ${pluginName}:`, e);
+        }
+    }
 })
     .demandCommand(1)
     .strict(true)

package/build/src/factory.js

@@ -31,6 +31,7 @@ exports.getReleaserTypes = exports.unregisterReleaseType = exports.registerRelea
 const go_1 = require("./strategies/go");
 const go_yoshi_1 = require("./strategies/go-yoshi");
 const java_yoshi_1 = require("./strategies/java-yoshi");
+const java_yoshi_mono_repo_1 = require("./strategies/java-yoshi-mono-repo");
 const krm_blueprint_1 = require("./strategies/krm-blueprint");
 const ocaml_1 = require("./strategies/ocaml");
 const php_1 = require("./strategies/php");
@@ -65,6 +66,7 @@ const releasers = {
     java: options => new java_1.Java(options),
     maven: options => new maven_1.Maven(options),
     'java-yoshi': options => new java_yoshi_1.JavaYoshi(options),
+    'java-yoshi-mono-repo': options => new java_yoshi_mono_repo_1.JavaYoshiMonoRepo(options),
     'java-backport': options => new java_yoshi_1.JavaYoshi({
         ...options,
         versioningStrategy: new always_bump_patch_1.AlwaysBumpPatch(),

package/build/src/index.d.ts

@@ -1,6 +1,7 @@
 export * as Errors from './errors';
 export { Manifest, ReleaserConfig, ManifestOptions, PluginType, } from './manifest';
 export { Commit, ConventionalCommit } from './commit';
+export { Strategy } from './strategy';
 export { BaseStrategyOptions, BuildUpdatesOptions } from './strategies/base';
 export { ReleaseBuilder, ReleaseType, getReleaserTypes, registerReleaseType, } from './factory';
 export { ChangelogNotesBuilder, ChangelogNotesFactoryOptions, ChangelogNotesType, getChangelogTypes, registerChangelogNotes, } from './factories/changelog-notes-factory';

package/build/src/plugins/maven-workspace.js

@@ -28,7 +28,13 @@ const logger_1 = require("../util/logger");
 const java_snapshot_1 = require("../versioning-strategies/java-snapshot");
 const always_bump_patch_1 = require("../versioning-strategies/always-bump-patch");
 const composite_1 = require("../updaters/composite");
-const JAVA_RELEASE_TYPES = new Set(['java', 'java-bom', 'java-yoshi', 'maven']);
+const JAVA_RELEASE_TYPES = new Set([
+    'java',
+    'java-bom',
+    'java-yoshi',
+    'java-yoshi-mono-repo',
+    'maven',
+]);
 const XPATH_PROJECT_GROUP = '/*[local-name()="project"]/*[local-name()="groupId"]';
 const XPATH_PROJECT_ARTIFACT = '/*[local-name()="project"]/*[local-name()="artifactId"]';
 const XPATH_PROJECT_VERSION = '/*[local-name()="project"]/*[local-name()="version"]';

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

@@ -15,6 +15,7 @@ import { PullRequestBody } from '../util/pull-request-body';
 import { PullRequest } from '../pull-request';
 export interface BuildUpdatesOptions {
     changelogEntry: string;
+    commits?: ConventionalCommit[];
     newVersion: Version;
     versionsMap: VersionsMap;
     latestVersion?: Version;

package/build/src/strategies/base.js

@@ -165,6 +165,7 @@ class BaseStrategy {
             newVersion,
             versionsMap,
             latestVersion: latestRelease === null || latestRelease === void 0 ? void 0 : latestRelease.tag.version,
+            commits: conventionalCommits,
         });
         const updatesWithExtras = (0, composite_1.mergeUpdates)(updates.concat(...(await this.extraFileUpdates(newVersion, versionsMap))));
         const pullRequestBody = await this.buildPullRequestBody(component, newVersion, releaseNotesBody, conventionalCommits, latestRelease, this.pullRequestHeader);

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

@@ -0,0 +1,21 @@
+import { Update } from '../update';
+import { Version, VersionsMap } from '../version';
+import { GitHubFileContents } from '@google-automations/git-file-utils';
+import { ConventionalCommit } from '../commit';
+import { Java, JavaBuildUpdatesOption } from './java';
+export declare class JavaYoshiMonoRepo extends Java {
+    private versionsContent?;
+    /**
+     * Override this method to post process commits
+     * @param {ConventionalCommit[]} commits parsed commits
+     * @returns {ConventionalCommit[]} modified commits
+     */
+    protected postProcessCommits(commits: ConventionalCommit[]): Promise<ConventionalCommit[]>;
+    protected needsSnapshot(): Promise<boolean>;
+    protected buildVersionsMap(): Promise<VersionsMap>;
+    protected getVersionsContent(): Promise<GitHubFileContents>;
+    protected buildUpdates(options: JavaBuildUpdatesOption): Promise<Update[]>;
+    private getArtifactMap;
+    protected updateVersionsMap(versionsMap: VersionsMap, conventionalCommits: ConventionalCommit[]): Promise<VersionsMap>;
+    protected initialReleaseVersion(): Version;
+}

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

@@ -0,0 +1,254 @@
+"use strict";
+// Copyright 2023 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.JavaYoshiMonoRepo = void 0;
+const versions_manifest_1 = require("../updaters/java/versions-manifest");
+const version_1 = require("../version");
+const changelog_1 = require("../updaters/changelog");
+const changelog_json_1 = require("../updaters/changelog-json");
+const commit_split_1 = require("../util/commit-split");
+const composite_1 = require("../updaters/composite");
+const errors_1 = require("../errors");
+const java_1 = require("./java");
+const java_update_1 = require("../updaters/java/java-update");
+const BREAKING_CHANGE_NOTE = 'BREAKING CHANGE';
+class JavaYoshiMonoRepo extends java_1.Java {
+    /**
+     * Override this method to post process commits
+     * @param {ConventionalCommit[]} commits parsed commits
+     * @returns {ConventionalCommit[]} modified commits
+     */
+    async postProcessCommits(commits) {
+        if (commits.length === 0) {
+            // For Java commits, push a fake commit so we force a
+            // SNAPSHOT release
+            commits.push({
+                type: 'fake',
+                bareMessage: 'fake commit',
+                message: 'fake commit',
+                breaking: false,
+                scope: null,
+                notes: [],
+                files: [],
+                references: [],
+                sha: 'fake',
+            });
+        }
+        return commits;
+    }
+    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'), JavaYoshiMonoRepo.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.findFilesByFilenameAndRef('pom.xml', this.targetBranch, this.path);
+        const buildFilesSearch = this.github.findFilesByFilenameAndRef('build.gradle', this.targetBranch, this.path);
+        const dependenciesSearch = this.github.findFilesByFilenameAndRef('dependencies.properties', this.targetBranch, 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,
+                    isSnapshot: options.isSnapshot,
+                }),
+            });
+        });
+        const buildFiles = await buildFilesSearch;
+        buildFiles.forEach(path => {
+            updates.push({
+                path: this.addPath(path),
+                createIfMissing: false,
+                updater: new java_update_1.JavaUpdate({
+                    version,
+                    versionsMap,
+                    isSnapshot: options.isSnapshot,
+                }),
+            });
+        });
+        const dependenciesFiles = await dependenciesSearch;
+        dependenciesFiles.forEach(path => {
+            updates.push({
+                path: this.addPath(path),
+                createIfMissing: false,
+                updater: new java_update_1.JavaUpdate({
+                    version,
+                    versionsMap,
+                    isSnapshot: options.isSnapshot,
+                }),
+            });
+        });
+        this.extraFiles.forEach(extraFile => {
+            if (typeof extraFile === 'object') {
+                return;
+            }
+            updates.push({
+                path: extraFile,
+                createIfMissing: false,
+                updater: new java_update_1.JavaUpdate({
+                    version,
+                    versionsMap,
+                    isSnapshot: options.isSnapshot,
+                }),
+            });
+        });
+        if (!options.isSnapshot) {
+            updates.push({
+                path: this.addPath(this.changelogPath),
+                createIfMissing: true,
+                updater: new changelog_1.Changelog({
+                    version,
+                    changelogEntry: options.changelogEntry,
+                }),
+            });
+            // The artifact map maps from directory paths in repo to artifact names on
+            // Maven, e.g, java-secretmanager to com.google.cloud/google-cloud-secretmanager.
+            const artifactMap = await this.getArtifactMap('artifact-map.json');
+            if (artifactMap && options.commits) {
+                const changelogUpdates = [];
+                const cs = new commit_split_1.CommitSplit({
+                    includeEmpty: false,
+                });
+                const splitCommits = cs.split(options.commits.filter(commit => {
+                    const isBreaking = commit.notes.find(note => {
+                        return note.title === BREAKING_CHANGE_NOTE;
+                    });
+                    return commit.type !== 'chore' || isBreaking;
+                }));
+                for (const path of Object.keys(splitCommits)) {
+                    if (artifactMap[path]) {
+                        this.logger.info(`Found artifact ${artifactMap[path]} for ${path}`);
+                        changelogUpdates.push(new changelog_json_1.ChangelogJson({
+                            artifactName: artifactMap[path],
+                            version,
+                            // We filter out "chore:" commits, to reduce noise in the upstream
+                            // release notes. We will only show a product release note entry
+                            // if there has been a substantial change, such as a fix or feature.
+                            commits: splitCommits[path],
+                            language: 'JAVA',
+                        }));
+                    }
+                }
+                updates.push({
+                    path: 'changelog.json',
+                    createIfMissing: false,
+                    updater: new composite_1.CompositeUpdater(...changelogUpdates),
+                });
+            }
+        }
+        return updates;
+    }
+    async getArtifactMap(path) {
+        try {
+            const content = await this.github.getFileContentsOnBranch(path, this.targetBranch);
+            return JSON.parse(content.parsedContent);
+        }
+        catch (e) {
+            return null;
+        }
+    }
+    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) {
+                this.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.JavaYoshiMonoRepo = JavaYoshiMonoRepo;
+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-mono-repo.js.map

package/build/src/strategies/java.js

@@ -93,6 +93,7 @@ class Java extends base_1.BaseStrategy {
             versionsMap,
             changelogEntry: notes,
             isSnapshot: true,
+            commits: [],
         });
         const updatesWithExtras = (0, composite_1.mergeUpdates)(updates.concat(...(await this.extraFileUpdates(newVersion, versionsMap))));
         return {

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

@@ -110,6 +110,7 @@ class PHPYoshi extends base_1.BaseStrategy {
             newVersion,
             versionsMap,
             latestVersion: latestRelease === null || latestRelease === void 0 ? void 0 : latestRelease.tag.version,
+            commits: conventionalCommits, // TODO(@bcoe): these commits will need to be divided into multiple changelog.json updates.
         });
         for (const directory in directoryVersionContents) {
             const componentInfo = directoryVersionContents[directory];

package/build/src/updaters/changelog-json.d.ts

@@ -0,0 +1,29 @@
+import { ConventionalCommit } from '../commit';
+import { Logger } from '../util/logger';
+import { DefaultUpdater, UpdateOptions } from './default';
+interface ChangelogJsonOptions extends UpdateOptions {
+    artifactName: string;
+    language: string;
+    commits: ConventionalCommit[];
+}
+/**
+ * Maintians a machine readable CHANGELOG in chnagelog.json.
+ * See: https://gist.github.com/bcoe/50ef0a0024bbf107cd5bc0adbdc04758
+ */
+export declare class ChangelogJson extends DefaultUpdater {
+    artifactName: string;
+    language: string;
+    commits: ConventionalCommit[];
+    /**
+     * Instantiate a new SamplesPackageJson updater
+     * @param options
+     */
+    constructor(options: ChangelogJsonOptions);
+    /**
+     * Given initial file contents, return updated contents.
+     * @param {string} content The initial content
+     * @returns {string} The updated content
+     */
+    updateContent(content: string, logger?: Logger): string;
+}
+export {};

package/build/src/updaters/changelog-json.js

@@ -0,0 +1,82 @@
+"use strict";
+// Copyright 2023 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.ChangelogJson = void 0;
+const logger_1 = require("../util/logger");
+const default_1 = require("./default");
+const crypto_1 = require("crypto");
+const BREAKING_CHANGE_TITLE = 'BREAKING CHANGE';
+const COMMIT_PREFIX = /^[^:]+: ?/;
+/**
+ * Maintians a machine readable CHANGELOG in chnagelog.json.
+ * See: https://gist.github.com/bcoe/50ef0a0024bbf107cd5bc0adbdc04758
+ */
+class ChangelogJson extends default_1.DefaultUpdater {
+    /**
+     * Instantiate a new SamplesPackageJson updater
+     * @param options
+     */
+    constructor(options) {
+        super(options);
+        this.language = options.language;
+        this.artifactName = options.artifactName;
+        this.commits = options.commits;
+    }
+    /**
+     * Given initial file contents, return updated contents.
+     * @param {string} content The initial content
+     * @returns {string} The updated content
+     */
+    updateContent(content, logger = logger_1.logger) {
+        const parsed = JSON.parse(content);
+        logger.info(`adding release ${this.version} for ${this.artifactName}`);
+        const changes = [];
+        for (const commit of this.commits) {
+            // The commit.message field contains the type/scope prefix.
+            const message = commit.message.replace(COMMIT_PREFIX, '');
+            const change = {
+                type: commit.type,
+                sha: commit.sha,
+                message: message,
+            };
+            if (commit.scope)
+                change.scope = commit.scope;
+            for (const note of commit.notes) {
+                if (note.title === BREAKING_CHANGE_TITLE) {
+                    change.breakingChangeNote = note.text;
+                }
+            }
+            changes.push(change);
+        }
+        // If all commits were ignored, simply return the original changelog.json.
+        if (changes.length === 0) {
+            return content;
+        }
+        const time = new Date().toISOString();
+        const release = {
+            changes,
+            version: this.version.toString(),
+            language: this.language,
+            artifactName: this.artifactName,
+            id: (0, crypto_1.randomUUID)(),
+            createTime: time,
+        };
+        parsed.entries.unshift(release);
+        parsed.updateTime = time;
+        return JSON.stringify(parsed, null, 2);
+    }
+}
+exports.ChangelogJson = ChangelogJson;
+//# sourceMappingURL=changelog-json.js.map

package/build/src/updaters/ruby/gemfile-lock.js

@@ -40,6 +40,9 @@ class GemfileLock extends default_1.DefaultUpdater {
      * @returns {string} The updated content
      */
     updateContent(content) {
+        if (!this.gemName) {
+            return content;
+        }
         // Bundler will convert 1.0.0-alpha1 to 1.0.0.pre.alpha1, so we need to
         // do the same here.
         const versionString = (0, common_1.resolveRubyGemfileLockVersion)(this.version.toString());

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "release-please",
-  "version": "15.1.1",
+  "version": "15.2.0",
   "description": "generate release PRs based on the conventionalcommits.org spec",
   "main": "./build/src/index.js",
   "bin": "./build/src/bin/release-please.js",
@@ -38,7 +38,7 @@
     }
   },
   "devDependencies": {
-    "@octokit/types": "^8.0.0",
+    "@octokit/types": "^9.0.0",
     "@types/chai": "^4.1.7",
     "@types/diff": "^5.0.2",
     "@types/iarna__toml": "^2.0.1",