release-please 14.7.2 → 14.8.0

package/CHANGELOG.md

@@ -4,6 +4,18 @@
 
 [1]: https://www.npmjs.com/package/release-please?activeTab=versions
 
+## [14.8.0](https://github.com/googleapis/release-please/compare/v14.7.2...v14.8.0) (2022-09-28)
+
+
+### Features
+
+* Add `group-priority` plugin ([#1660](https://github.com/googleapis/release-please/issues/1660)) ([3ca750a](https://github.com/googleapis/release-please/commit/3ca750af3be8af06f9b6d0ed835524d53eab09c5))
+
+
+### Bug Fixes
+
+* Escape html tags in release notes ([#1661](https://github.com/googleapis/release-please/issues/1661)) ([891fdcb](https://github.com/googleapis/release-please/commit/891fdcb0776abd8b3518bb60c44873f55fd616a3))
+
 ## [14.7.2](https://github.com/googleapis/release-please/compare/v14.7.1...v14.7.2) (2022-09-26)
 
 

package/build/src/changelog-notes/default.js

@@ -49,7 +49,7 @@ class DefaultChangelogNotes {
         const changelogCommits = commits.map(commit => {
             return {
                 body: '',
-                subject: commit.bareMessage,
+                subject: htmlEscape(commit.bareMessage),
                 type: commit.type,
                 scope: commit.scope,
                 notes: commit.notes.filter(note => note.title === 'BREAKING CHANGE'),
@@ -71,4 +71,7 @@ class DefaultChangelogNotes {
     }
 }
 exports.DefaultChangelogNotes = DefaultChangelogNotes;
+function htmlEscape(message) {
+    return message.replace('<', '&lt;').replace('>', '&gt;');
+}
 //# sourceMappingURL=default.js.map

package/build/src/factories/plugin-factory.js

@@ -20,12 +20,14 @@ const node_workspace_1 = require("../plugins/node-workspace");
 const maven_workspace_1 = require("../plugins/maven-workspace");
 const errors_1 = require("../errors");
 const sentence_case_1 = require("../plugins/sentence-case");
+const group_priority_1 = require("../plugins/group-priority");
 const pluginFactories = {
     'linked-versions': options => new linked_versions_1.LinkedVersions(options.github, options.targetBranch, options.repositoryConfig, options.type.groupName, options.type.components),
     'cargo-workspace': options => new cargo_workspace_1.CargoWorkspace(options.github, options.targetBranch, options.repositoryConfig, options),
     'node-workspace': options => new node_workspace_1.NodeWorkspace(options.github, options.targetBranch, options.repositoryConfig, options),
     'maven-workspace': options => new maven_workspace_1.MavenWorkspace(options.github, options.targetBranch, options.repositoryConfig, options),
     'sentence-case': options => new sentence_case_1.SentenceCase(options.github, options.targetBranch, options.repositoryConfig, options.type.specialWords),
+    'group-priority': options => new group_priority_1.GroupPriority(options.github, options.targetBranch, options.repositoryConfig, options.type.groups),
 };
 function buildPlugin(options) {
     if (typeof options.type === 'object') {

package/build/src/manifest.d.ts

@@ -142,7 +142,10 @@ export interface SentenceCasePluginConfig extends ConfigurablePluginType {
 export interface WorkspacePluginConfig extends ConfigurablePluginType {
     merge?: boolean;
 }
-export declare type PluginType = DirectPluginType | ConfigurablePluginType | LinkedVersionPluginConfig | SentenceCasePluginConfig | WorkspacePluginConfig;
+export interface GroupPriorityPluginConfig extends ConfigurablePluginType {
+    groups: string[];
+}
+export declare type PluginType = DirectPluginType | ConfigurablePluginType | GroupPriorityPluginConfig | LinkedVersionPluginConfig | SentenceCasePluginConfig | WorkspacePluginConfig;
 /**
  * This is the schema of the manifest config json
  */

package/build/src/plugins/group-priority.d.ts

@@ -0,0 +1,29 @@
+import { ManifestPlugin } from '../plugin';
+import { GitHub } from '../github';
+import { RepositoryConfig, CandidateReleasePullRequest } from '../manifest';
+/**
+ * This plugin allows configuring a priority of release groups. For example, you could
+ * prioritize Java snapshot pull requests over other releases.
+ */
+export declare class GroupPriority extends ManifestPlugin {
+    readonly groups: string[];
+    /**
+     * Instantiate a new GroupPriority plugin.
+     *
+     * @param {GitHub} github GitHub client
+     * @param {string} targetBranch Release branch
+     * @param {RepositoryConfig} repositoryConfig Parsed configuration for the entire
+     *   repository. This allows plugins to know how components interact.
+     * @param {string[]} groups List of group names ordered with highest priority first
+     */
+    constructor(github: GitHub, targetBranch: string, repositoryConfig: RepositoryConfig, groups: string[]);
+    /**
+     * Group candidate release PRs by grouping and check our list of preferred
+     * groups in order. If a preferred group is found, only return pull requests for
+     * that group.
+     * @param {CandidateReleasePullRequest[]} pullRequests Candidate pull requests
+     * @returns {CandidateReleasePullRequest[]} Possibly a subset of the candidate
+     *   pull requests if a preferred group is found.
+     */
+    run(pullRequests: CandidateReleasePullRequest[]): Promise<CandidateReleasePullRequest[]>;
+}

package/build/src/plugins/group-priority.js

@@ -0,0 +1,82 @@
+"use strict";
+// Copyright 2022 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.GroupPriority = void 0;
+const plugin_1 = require("../plugin");
+/**
+ * This plugin allows configuring a priority of release groups. For example, you could
+ * prioritize Java snapshot pull requests over other releases.
+ */
+class GroupPriority extends plugin_1.ManifestPlugin {
+    /**
+     * Instantiate a new GroupPriority plugin.
+     *
+     * @param {GitHub} github GitHub client
+     * @param {string} targetBranch Release branch
+     * @param {RepositoryConfig} repositoryConfig Parsed configuration for the entire
+     *   repository. This allows plugins to know how components interact.
+     * @param {string[]} groups List of group names ordered with highest priority first
+     */
+    constructor(github, targetBranch, repositoryConfig, groups) {
+        super(github, targetBranch, repositoryConfig);
+        this.groups = groups;
+    }
+    /**
+     * Group candidate release PRs by grouping and check our list of preferred
+     * groups in order. If a preferred group is found, only return pull requests for
+     * that group.
+     * @param {CandidateReleasePullRequest[]} pullRequests Candidate pull requests
+     * @returns {CandidateReleasePullRequest[]} Possibly a subset of the candidate
+     *   pull requests if a preferred group is found.
+     */
+    async run(pullRequests) {
+        this.logger.debug(`Group priority plugin running with groups: ${this.groups}`);
+        const groupedCandidates = groupCandidatesByType(pullRequests);
+        for (const group of this.groups) {
+            this.logger.debug(`Considering group: ${group}`);
+            const groupCandidates = groupedCandidates.get(group);
+            if (groupCandidates) {
+                this.logger.debug(`Found preferred group: ${group} with ${groupCandidates.length} candidate pull requests`);
+                return groupCandidates;
+            }
+        }
+        // fallback to returning all candidates
+        this.logger.debug('No preferred group found, returning full set.');
+        return pullRequests;
+    }
+}
+exports.GroupPriority = GroupPriority;
+/**
+ * Helper to group candidates by their `type` field.
+ * @param {CandidateReleasePullRequest[]} inScopeCandidates The candidates to group.
+ * @returns {Map<string|undefined, CandidateReleasePullRequest[]>} The grouped
+ *   pull requests.
+ */
+function groupCandidatesByType(inScopeCandidates) {
+    const groupedCandidates = new Map();
+    for (const candidatePullRequest of inScopeCandidates) {
+        const candidates = groupedCandidates.get(candidatePullRequest.pullRequest.group);
+        if (candidates) {
+            candidates.push(candidatePullRequest);
+        }
+        else {
+            groupedCandidates.set(candidatePullRequest.pullRequest.group, [
+                candidatePullRequest,
+            ]);
+        }
+    }
+    return groupedCandidates;
+}
+//# sourceMappingURL=group-priority.js.map

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

@@ -9,5 +9,6 @@ export interface ReleasePullRequest {
     readonly headRefName: string;
     readonly version?: Version;
     readonly draft: boolean;
+    readonly group?: string;
     updates: Update[];
 }

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

@@ -122,6 +122,7 @@ export declare abstract class BaseStrategy implements Strategy {
      * @returns {Release} The candidate release.
      */
     buildRelease(mergedPullRequest: PullRequest): Promise<Release | undefined>;
+    isPublishedVersion(_version: Version): boolean;
     /**
      * Override this to handle the initial version of a new library.
      */

package/build/src/strategies/base.js

@@ -346,6 +346,10 @@ class BaseStrategy {
             this.logger.error('Pull request should have included version');
             return;
         }
+        if (!this.isPublishedVersion(version)) {
+            this.logger.warn(`Skipping non-published version: ${version.toString()}`);
+            return;
+        }
         const tag = new tag_name_1.TagName(version, this.includeComponentInTag ? component : undefined, this.tagSeparator, this.includeVInTag);
         const releaseName = component && this.includeComponentInTag
             ? `${component}: v${version.toString()}`
@@ -357,6 +361,9 @@ class BaseStrategy {
             sha: mergedPullRequest.sha,
         };
     }
+    isPublishedVersion(_version) {
+        return true;
+    }
     /**
      * Override this to handle the initial version of a new library.
      */

package/build/src/strategies/java.js

@@ -103,6 +103,7 @@ class Java extends base_1.BaseStrategy {
             headRefName: branchName.toString(),
             version: newVersion,
             draft: draft !== null && draft !== void 0 ? draft : false,
+            group: 'snapshot',
         };
     }
     isPublishedVersion(version) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "release-please",
-  "version": "14.7.2",
+  "version": "14.8.0",
   "description": "generate release PRs based on the conventionalcommits.org spec",
   "main": "./build/src/index.js",
   "bin": "./build/src/bin/release-please.js",

package/schemas/config.json

@@ -295,6 +295,24 @@
                   }
                 }
               },
+              {
+                "description": "Configuration for various `group-priority` plugin",
+                "type": "object",
+                "properties": {
+                  "type": {
+                    "description": "The name of the plugin.",
+                    "type": "string",
+                    "enum": ["group-priority"]
+                  },
+                  "groups": {
+                    "description": "Group names ordered with highest priority first.",
+                    "type": "array",
+                    "items": {
+                      "type": "string"
+                    }
+                  }
+                }
+              },
               {
                 "description": "Other plugins",
                 "type": "object",