release-please 12.6.0 → 12.6.1

package/CHANGELOG.md

@@ -4,6 +4,13 @@
 
 [1]: https://www.npmjs.com/package/release-please?activeTab=versions
 
+### [12.6.1](https://www.github.com/googleapis/release-please/compare/v12.6.0...v12.6.1) (2021-12-21)
+
+
+### Bug Fixes
+
+* **rust:** Don't update dev-dependencies lacking a version key ([#1095](https://www.github.com/googleapis/release-please/issues/1095)) ([dc1bad9](https://www.github.com/googleapis/release-please/commit/dc1bad997ef0d028e280e75b0e6510a99d06cb44))
+
 ## [12.6.0](https://www.github.com/googleapis/release-please/compare/v12.5.0...v12.6.0) (2021-10-11)
 
 

package/build/src/bootstrapper.d.ts

@@ -0,0 +1,12 @@
+import { GitHub } from './github';
+import { ReleaserConfig } from './manifest';
+import { PullRequest } from './pull-request';
+export declare class Bootstrapper {
+    private github;
+    private targetBranch;
+    private manifestFile;
+    private configFile;
+    private initialVersion;
+    constructor(github: GitHub, targetBranch: string, manifestFile?: string, configFile?: string, initialVersionString?: string);
+    bootstrap(path: string, config: ReleaserConfig): Promise<PullRequest>;
+}

package/build/src/bootstrapper.js

@@ -0,0 +1,60 @@
+"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.Bootstrapper = void 0;
+const manifest_1 = require("./manifest");
+const version_1 = require("./version");
+const release_please_manifest_1 = require("./updaters/release-please-manifest");
+const release_please_config_1 = require("./updaters/release-please-config");
+class Bootstrapper {
+    constructor(github, targetBranch, manifestFile = manifest_1.DEFAULT_RELEASE_PLEASE_MANIFEST, configFile = manifest_1.DEFAULT_RELEASE_PLEASE_CONFIG, initialVersionString = '0.0.0') {
+        this.github = github;
+        this.targetBranch = targetBranch;
+        this.manifestFile = manifestFile;
+        this.configFile = configFile;
+        this.initialVersion = version_1.Version.parse(initialVersionString);
+    }
+    async bootstrap(path, config) {
+        const message = `chore: bootstrap releases for path: ${path}`;
+        const branchName = path === manifest_1.ROOT_PROJECT_PATH ? 'default' : path;
+        const pullRequest = {
+            headBranchName: `release-please/bootstrap/${branchName}`,
+            baseBranchName: this.targetBranch,
+            number: -1,
+            title: message,
+            body: `Configuring release-please for path: ${path}`,
+            labels: [],
+            files: [],
+        };
+        const version = this.initialVersion;
+        const versionsMap = new Map();
+        versionsMap.set(path, version);
+        const updates = [
+            {
+                path: this.manifestFile,
+                createIfMissing: true,
+                updater: new release_please_manifest_1.ReleasePleaseManifest({ version, versionsMap }),
+            },
+            {
+                path: this.configFile,
+                createIfMissing: true,
+                updater: new release_please_config_1.ReleasePleaseConfig(path, config),
+            },
+        ];
+        return await this.github.createPullRequest(pullRequest, this.targetBranch, message, updates, {});
+    }
+}
+exports.Bootstrapper = Bootstrapper;
+//# sourceMappingURL=bootstrapper.js.map

package/build/src/changelog-notes/default.d.ts

@@ -0,0 +1,15 @@
+import { ChangelogNotes, BuildNotesOptions } from '../changelog-notes';
+import { ConventionalCommit } from '../commit';
+interface DefaultChangelogNotesOptions {
+    commitPartial?: string;
+    headerPartial?: string;
+    mainTemplate?: string;
+}
+export declare class DefaultChangelogNotes implements ChangelogNotes {
+    private commitPartial?;
+    private headerPartial?;
+    private mainTemplate?;
+    constructor(options?: DefaultChangelogNotesOptions);
+    buildNotes(commits: ConventionalCommit[], options: BuildNotesOptions): Promise<string>;
+}
+export {};

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

@@ -0,0 +1,71 @@
+"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.DefaultChangelogNotes = void 0;
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const conventionalChangelogWriter = require('conventional-changelog-writer');
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const presetFactory = require('conventional-changelog-conventionalcommits');
+const DEFAULT_HOST = 'https://github.com';
+class DefaultChangelogNotes {
+    constructor(options = {}) {
+        this.commitPartial = options.commitPartial;
+        this.headerPartial = options.headerPartial;
+        this.mainTemplate = options.mainTemplate;
+    }
+    async buildNotes(commits, options) {
+        const context = {
+            host: options.host || DEFAULT_HOST,
+            owner: options.owner,
+            repository: options.repository,
+            version: options.version,
+            previousTag: options.previousTag,
+            currentTag: options.currentTag,
+            linkCompare: !!options.previousTag,
+        };
+        const config = {};
+        if (options.changelogSections) {
+            config.types = options.changelogSections;
+        }
+        const preset = await presetFactory(config);
+        preset.writerOpts.commitPartial =
+            this.commitPartial || preset.writerOpts.commitPartial;
+        preset.writerOpts.headerPartial =
+            this.headerPartial || preset.writerOpts.headerPartial;
+        preset.writerOpts.mainTemplate =
+            this.mainTemplate || preset.writerOpts.mainTemplate;
+        const changelogCommits = commits.map(commit => {
+            return {
+                body: '',
+                subject: commit.bareMessage,
+                type: commit.type,
+                scope: commit.scope,
+                notes: commit.notes,
+                references: commit.references,
+                mentions: [],
+                merge: null,
+                revert: null,
+                header: commit.message,
+                footer: null,
+                hash: commit.sha,
+            };
+        });
+        return conventionalChangelogWriter
+            .parseArray(changelogCommits, context, preset.writerOpts)
+            .trim();
+    }
+}
+exports.DefaultChangelogNotes = DefaultChangelogNotes;
+//# sourceMappingURL=default.js.map

package/build/src/changelog-notes/github.d.ts

@@ -0,0 +1,8 @@
+import { ChangelogNotes, BuildNotesOptions } from '../changelog-notes';
+import { ConventionalCommit } from '../commit';
+import { GitHub } from '../github';
+export declare class GitHubChangelogNotes implements ChangelogNotes {
+    private github;
+    constructor(github: GitHub);
+    buildNotes(_commits: ConventionalCommit[], options: BuildNotesOptions): Promise<string>;
+}

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

@@ -0,0 +1,26 @@
+"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.GitHubChangelogNotes = void 0;
+class GitHubChangelogNotes {
+    constructor(github) {
+        this.github = github;
+    }
+    async buildNotes(_commits, options) {
+        return await this.github.generateReleaseNotes(options.currentTag, options.targetBranch, options.previousTag);
+    }
+}
+exports.GitHubChangelogNotes = GitHubChangelogNotes;
+//# sourceMappingURL=github.js.map

package/build/src/changelog-notes.d.ts

@@ -0,0 +1,19 @@
+import { ConventionalCommit } from './commit';
+export interface BuildNotesOptions {
+    host?: string;
+    owner: string;
+    repository: string;
+    version: string;
+    previousTag?: string;
+    currentTag: string;
+    targetBranch: string;
+    changelogSections?: ChangelogSection[];
+}
+export interface ChangelogNotes {
+    buildNotes(commits: ConventionalCommit[], options: BuildNotesOptions): Promise<string>;
+}
+export interface ChangelogSection {
+    type: string;
+    section: string;
+    hidden?: boolean;
+}

package/build/src/changelog-notes.js

@@ -0,0 +1,16 @@
+"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 });
+//# sourceMappingURL=changelog-notes.js.map

package/build/src/commit.d.ts

@@ -0,0 +1,26 @@
+import { PullRequest } from './pull-request';
+import * as parser from '@conventional-commits/parser';
+export interface Commit {
+    sha: string;
+    message: string;
+    files: string[];
+    pullRequest?: PullRequest;
+}
+export interface ConventionalCommit extends Commit {
+    type: string;
+    scope: string | null;
+    notes: parser.Note[];
+    references: parser.Reference[];
+    bareMessage: string;
+    breaking: boolean;
+}
+/**
+ * Given a list of raw commits, parse and expand into conventional commits.
+ *
+ * @param commits {Commit[]} The input commits
+ *
+ * @returns {ConventionalCommit[]} Parsed and expanded commits. There may be
+ *   more commits returned as a single raw commit may contain multiple release
+ *   messages.
+ */
+export declare function parseConventionalCommits(commits: Commit[]): ConventionalCommit[];

package/build/src/commit.js

@@ -0,0 +1,316 @@
+"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.parseConventionalCommits = void 0;
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const visit = require('unist-util-visit');
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const visitWithAncestors = require('unist-util-visit-parents');
+const NUMBER_REGEX = /^[0-9]+$/;
+const logger_1 = require("./util/logger");
+const parser = require("@conventional-commits/parser");
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const conventionalCommitsFilter = require('conventional-commits-filter');
+function getBlankConventionalCommit() {
+    return {
+        body: '',
+        subject: '',
+        type: '',
+        scope: null,
+        notes: [],
+        references: [],
+        mentions: [],
+        merge: null,
+        revert: null,
+        header: '',
+        footer: null,
+    };
+}
+// Converts conventional commit AST into conventional-changelog's
+// output format, see: https://www.npmjs.com/package/conventional-commits-parser
+function toConventionalChangelogFormat(ast) {
+    const commits = [];
+    const headerCommit = getBlankConventionalCommit();
+    // Separate the body and summary nodes, this simplifies the subsequent
+    // tree walking logic:
+    let body;
+    let summary;
+    visit(ast, ['body', 'summary'], (node) => {
+        switch (node.type) {
+            case 'body':
+                body = node;
+                break;
+            case 'summary':
+                summary = node;
+                break;
+        }
+    });
+    // <type>, "(", <scope>, ")", ["!"], ":", <whitespace>*, <text>
+    visit(summary, (node) => {
+        switch (node.type) {
+            case 'type':
+                headerCommit.type = node.value;
+                headerCommit.header += node.value;
+                break;
+            case 'scope':
+                headerCommit.scope = node.value;
+                headerCommit.header += `(${node.value})`;
+                break;
+            case 'breaking-change':
+                headerCommit.header += '!';
+                break;
+            case 'text':
+                headerCommit.subject = node.value;
+                headerCommit.header += `: ${node.value}`;
+                break;
+            default:
+                break;
+        }
+    });
+    // [<any body-text except pre-footer>]
+    if (body) {
+        visit(body, ['text', 'newline'], (node) => {
+            headerCommit.body += node.value;
+        });
+    }
+    // Extract BREAKING CHANGE notes, regardless of whether they fall in
+    // summary, body, or footer:
+    const breaking = {
+        title: 'BREAKING CHANGE',
+        text: '',
+    };
+    visitWithAncestors(ast, ['breaking-change'], (node, ancestors) => {
+        let parent = ancestors.pop();
+        if (!parent) {
+            return;
+        }
+        switch (parent.type) {
+            case 'summary':
+                breaking.text = headerCommit.subject;
+                break;
+            case 'body':
+                breaking.text = '';
+                // We treat text from the BREAKING CHANGE marker forward as
+                // the breaking change notes:
+                visit(parent, ['text', 'newline'], (node) => {
+                    breaking.text += node.value;
+                });
+                break;
+            case 'token':
+                // If the '!' breaking change marker is used, the breaking change
+                // will be identified when the footer is parsed as a commit:
+                if (!node.value.includes('BREAKING'))
+                    return;
+                parent = ancestors.pop();
+                visit(parent, ['text', 'newline'], (node) => {
+                    breaking.text = node.value;
+                });
+                break;
+        }
+    });
+    if (breaking.text !== '')
+        headerCommit.notes.push(breaking);
+    // Populates references array from footers:
+    // references: [{
+    //    action: 'Closes',
+    //    owner: null,
+    //    repository: null,
+    //    issue: '1', raw: '#1',
+    //    prefix: '#'
+    // }]
+    visit(ast, ['footer'], (node) => {
+        const reference = {
+            prefix: '#',
+            action: '',
+            issue: '',
+        };
+        let hasRefSepartor = false;
+        visit(node, ['type', 'separator', 'text'], (node) => {
+            switch (node.type) {
+                case 'type':
+                    // refs, closes, etc:
+                    // TODO(@bcoe): conventional-changelog does not currently use
+                    // "reference.action" in its templates:
+                    reference.action = node.value;
+                    break;
+                case 'separator':
+                    // Footer of the form "Refs #99":
+                    if (node.value.includes('#'))
+                        hasRefSepartor = true;
+                    break;
+                case 'text':
+                    // Footer of the form "Refs: #99"
+                    if (node.value.charAt(0) === '#') {
+                        hasRefSepartor = true;
+                        reference.issue = node.value.substring(1);
+                        // TODO(@bcoe): what about references like "Refs: #99, #102"?
+                    }
+                    else {
+                        reference.issue = node.value;
+                    }
+                    break;
+            }
+        });
+        // TODO(@bcoe): how should references like "Refs: v8:8940" work.
+        if (hasRefSepartor && reference.issue.match(NUMBER_REGEX)) {
+            headerCommit.references.push(reference);
+        }
+    });
+    /*
+     * Split footers that resemble commits into additional commits, e.g.,
+     * chore: multiple commits
+     * chore(recaptchaenterprise): migrate recaptchaenterprise to the Java microgenerator
+     *   Committer: @miraleung
+     *   PiperOrigin-RevId: 345559154
+     * ...
+     */
+    visitWithAncestors(ast, ['type'], (node, ancestors) => {
+        let parent = ancestors.pop();
+        if (!parent) {
+            return;
+        }
+        if (parent.type === 'token') {
+            parent = ancestors.pop();
+            let footerText = '';
+            const semanticFooter = node.value.toLowerCase() === 'release-as';
+            visit(parent, ['type', 'scope', 'breaking-change', 'separator', 'text', 'newline'], (node) => {
+                switch (node.type) {
+                    case 'scope':
+                        footerText += `(${node.value})`;
+                        break;
+                    case 'separator':
+                        // Footers of the form Fixes #99, should not be parsed.
+                        if (node.value.includes('#'))
+                            return;
+                        footerText += `${node.value} `;
+                        break;
+                    default:
+                        footerText += node.value;
+                        break;
+                }
+            });
+            // Any footers that carry semantic meaning, e.g., Release-As, should
+            // be added to the footer field, for the benefits of post-processing:
+            if (semanticFooter) {
+                let releaseAs = '';
+                visit(parent, ['text'], (node) => {
+                    releaseAs = node.value;
+                });
+                // record Release-As footer as a note
+                headerCommit.notes.push({
+                    title: 'RELEASE AS',
+                    text: releaseAs,
+                });
+                if (!headerCommit.footer)
+                    headerCommit.footer = '';
+                headerCommit.footer += `\n${footerText.toLowerCase()}`.trimStart();
+            }
+            try {
+                for (const commit of toConventionalChangelogFormat(parser.parser(footerText))) {
+                    commits.push(commit);
+                }
+            }
+            catch (err) {
+                // Footer does not appear to be an additional commit.
+            }
+        }
+    });
+    commits.push(headerCommit);
+    return commits;
+}
+// TODO(@bcoe): now that we walk the actual AST of conventional commits
+// we should be able to move post processing into
+// to-conventional-changelog.ts.
+function postProcessCommits(commit) {
+    commit.notes.forEach(note => {
+        let text = '';
+        let i = 0;
+        let extendedContext = false;
+        for (const chunk of note.text.split(/\r?\n/)) {
+            if (i > 0 && hasExtendedContext(chunk) && !extendedContext) {
+                text = `${text.trim()}\n`;
+                extendedContext = true;
+            }
+            if (chunk === '')
+                break;
+            else if (extendedContext) {
+                text += `    ${chunk}\n`;
+            }
+            else {
+                text += `${chunk} `;
+            }
+            i++;
+        }
+        note.text = text.trim();
+    });
+    return commit;
+}
+// If someone wishes to include additional contextual information for a
+// BREAKING CHANGE using markdown, they can do so by starting the line after the initial
+// breaking change description with either:
+//
+// 1. a fourth-level header.
+// 2. a bulleted list (using either '*' or '-').
+//
+// BREAKING CHANGE: there were breaking changes
+// #### Deleted Endpoints
+// - endpoint 1
+// - endpoint 2
+function hasExtendedContext(line) {
+    if (line.match(/^#### |^[*-] /))
+        return true;
+    return false;
+}
+function parseCommits(message) {
+    return conventionalCommitsFilter(toConventionalChangelogFormat(parser.parser(message))).map(postProcessCommits);
+}
+/**
+ * Given a list of raw commits, parse and expand into conventional commits.
+ *
+ * @param commits {Commit[]} The input commits
+ *
+ * @returns {ConventionalCommit[]} Parsed and expanded commits. There may be
+ *   more commits returned as a single raw commit may contain multiple release
+ *   messages.
+ */
+function parseConventionalCommits(commits) {
+    const conventionalCommits = [];
+    for (const commit of commits) {
+        try {
+            for (const parsedCommit of parseCommits(commit.message)) {
+                const breaking = parsedCommit.notes.filter(note => note.title === 'BREAKING CHANGE')
+                    .length > 0;
+                conventionalCommits.push({
+                    sha: commit.sha,
+                    message: parsedCommit.header,
+                    files: commit.files,
+                    pullRequest: commit.pullRequest,
+                    type: parsedCommit.type,
+                    scope: parsedCommit.scope,
+                    bareMessage: parsedCommit.subject,
+                    notes: parsedCommit.notes,
+                    references: parsedCommit.references,
+                    breaking,
+                });
+            }
+        }
+        catch (_err) {
+            logger_1.logger.debug(`commit could not be parsed: ${commit.sha} ${commit.message.split('\n')[0]}`);
+        }
+    }
+    return conventionalCommits;
+}
+exports.parseConventionalCommits = parseConventionalCommits;
+//# sourceMappingURL=commit.js.map

package/build/src/github.js

@@ -538,7 +538,7 @@ class GitHub {
          * @throws {GitHubAPIError} on an API error
          */
         this.commentOnIssue = wrapAsync(async (comment, number) => {
-            logger_1.logger.info(`adding comment to https://github.com/${this.owner}/${this.repo}/issue/${number}`);
+            logger_1.logger.info(`adding comment to https://github.com/${this.owner}/${this.repo}/issues/${number}`);
             return (await this.request('POST /repos/:owner/:repo/issues/:issue_number/comments', {
                 owner: this.owner,
                 repo: this.repo,

package/build/src/plugin.d.ts

@@ -0,0 +1,20 @@
+import { GitHub } from './github';
+import { CandidateReleasePullRequest, RepositoryConfig } from './manifest';
+/**
+ * A plugin runs after a repository manifest has built candidate
+ * pull requests and can make updates that span across multiple
+ * components. A plugin *might* choose to merge pull requests or add
+ * or update existing files.
+ */
+export declare abstract class ManifestPlugin {
+    readonly github: GitHub;
+    readonly targetBranch: string;
+    readonly repositoryConfig: RepositoryConfig;
+    constructor(github: GitHub, targetBranch: string, repositoryConfig: RepositoryConfig);
+    /**
+     * Post-process candidate pull requests.
+     * @param {CandidateReleasePullRequest[]} pullRequests Candidate pull requests
+     * @returns {CandidateReleasePullRequest[]} Updated pull requests
+     */
+    abstract run(pullRequests: CandidateReleasePullRequest[]): Promise<CandidateReleasePullRequest[]>;
+}

package/build/src/plugin.js

@@ -0,0 +1,31 @@
+"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.ManifestPlugin = void 0;
+/**
+ * A plugin runs after a repository manifest has built candidate
+ * pull requests and can make updates that span across multiple
+ * components. A plugin *might* choose to merge pull requests or add
+ * or update existing files.
+ */
+class ManifestPlugin {
+    constructor(github, targetBranch, repositoryConfig) {
+        this.github = github;
+        this.targetBranch = targetBranch;
+        this.repositoryConfig = repositoryConfig;
+    }
+}
+exports.ManifestPlugin = ManifestPlugin;
+//# sourceMappingURL=plugin.js.map

package/build/src/plugins/merge.d.ts

@@ -0,0 +1,11 @@
+import { ManifestPlugin } from '../plugin';
+import { CandidateReleasePullRequest } from '../manifest';
+/**
+ * This plugin merges multiple pull requests into a single
+ * release pull request.
+ *
+ * Release notes are broken up using `<summary>`/`<details>` blocks.
+ */
+export declare class Merge extends ManifestPlugin {
+    run(candidates: CandidateReleasePullRequest[]): Promise<CandidateReleasePullRequest[]>;
+}