release-please 12.5.0 → 13.0.0-candidate.2

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,17 @@
+import { ChangelogSection, ChangelogNotes, BuildNotesOptions } from '../changelog-notes';
+import { ConventionalCommit } from '../commit';
+interface DefaultChangelogNotesOptions {
+    changelogSections?: ChangelogSection[];
+    commitPartial?: string;
+    headerPartial?: string;
+    mainTemplate?: string;
+}
+export declare class DefaultChangelogNotes implements ChangelogNotes {
+    private changelogSections?;
+    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,72 @@
+"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.changelogSections = options.changelogSections;
+        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 (this.changelogSections) {
+            config.types = this.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.d.ts

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

package/build/src/{updaters/java/readme.js → changelog-notes.js}

@@ -1,5 +1,5 @@
 "use strict";
-// Copyright 2019 Google LLC
+// 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.
@@ -13,9 +13,4 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Readme = void 0;
-const java_update_1 = require("./java_update");
-class Readme extends java_update_1.JavaUpdate {
-}
-exports.Readme = Readme;
-//# sourceMappingURL=readme.js.map
+//# 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/{util/to-conventional-changelog-format.js → commit.js}

@@ -13,12 +13,16 @@
 // 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: '',
@@ -200,6 +204,15 @@ function toConventionalChangelogFormat(ast) {
             // 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();
@@ -217,5 +230,87 @@ function toConventionalChangelogFormat(ast) {
     commits.push(headerCommit);
     return commits;
 }
-exports.default = toConventionalChangelogFormat;
-//# sourceMappingURL=to-conventional-changelog-format.js.map
+// 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/errors/index.d.ts

@@ -29,9 +29,4 @@ export declare class DuplicateReleaseError extends GitHubAPIError {
     tag: string;
     constructor(requestError: RequestError, tag: string);
 }
-export declare class MissingReleaseNotesError extends Error {
-    changelogContents: string;
-    version: string;
-    constructor(changelogContents: string, version: string);
-}
 export {};

package/build/src/errors/index.js

@@ -13,7 +13,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MissingReleaseNotesError = exports.DuplicateReleaseError = exports.AuthError = exports.GitHubAPIError = exports.MissingRequiredFileError = exports.ConfigurationError = void 0;
+exports.DuplicateReleaseError = exports.AuthError = exports.GitHubAPIError = exports.MissingRequiredFileError = exports.ConfigurationError = void 0;
 class ConfigurationError extends Error {
     constructor(message, releaserName, repository) {
         super(`${releaserName} (${repository}): ${message}`);
@@ -65,13 +65,4 @@ class DuplicateReleaseError extends GitHubAPIError {
     }
 }
 exports.DuplicateReleaseError = DuplicateReleaseError;
-class MissingReleaseNotesError extends Error {
-    constructor(changelogContents, version) {
-        super(`could not find changelog entry corresponding to release ${version}`);
-        this.changelogContents = changelogContents;
-        this.version = version;
-        this.name = MissingReleaseNotesError.name;
-    }
-}
-exports.MissingReleaseNotesError = MissingReleaseNotesError;
 //# sourceMappingURL=index.js.map

package/build/src/factory.d.ts

@@ -1,38 +1,26 @@
-import { ReleasePR } from './release-pr';
-import { GitHubRelease, GitHubReleaseResponse } from './github-release';
-import { ReleaseType } from './releasers';
-import { GitHub, GitHubTag } from './github';
-import { ManifestFactoryOptions, ReleasePRFactoryOptions, GitHubReleaseFactoryOptions, GitHubFactoryOptions } from '.';
-import { ManifestGitHubReleaseResult, Manifest } from './manifest';
-export declare type ManifestMethod = 'pullRequest' | 'githubRelease';
-export declare type ReleasePRMethod = 'run' | 'latestTag';
-export declare type GitHubReleaseMethod = 'run';
-export declare type Method = ManifestMethod | ReleasePRMethod | GitHubReleaseMethod;
-export declare type ManifestCommand = 'manifest-pr' | 'manifest-release';
-export declare type ReleasePRCommand = 'release-pr' | 'latest-tag';
-export declare type GitHubReleaseCommand = 'github-release';
-export declare type ManifestCallResult = Promise<number | undefined | ManifestGitHubReleaseResult>;
-export declare type ReleasePRCallResult = Promise<number | GitHubTag | undefined>;
-export declare type GitHubReleaseCallResult = Promise<GitHubReleaseResponse | undefined>;
-export declare type CallResult = ManifestCallResult | ReleasePRCallResult | GitHubReleaseCallResult;
-declare function runCommand(command: ManifestCommand, options: ManifestFactoryOptions): ManifestCallResult;
-declare function runCommand(command: ReleasePRCommand, options: ReleasePRFactoryOptions): ReleasePRCallResult;
-declare function runCommand(command: GitHubReleaseCommand, options: GitHubReleaseFactoryOptions): GitHubReleaseCallResult;
-declare function call(instance: Manifest, method: ManifestMethod): ManifestCallResult;
-declare function call(instance: ReleasePR, method: ReleasePRMethod): ReleasePRCallResult;
-declare function call(instance: GitHubRelease, method: GitHubReleaseMethod): GitHubReleaseCallResult;
-declare function manifest(options: ManifestFactoryOptions): Manifest;
-declare function githubRelease(options: GitHubReleaseFactoryOptions): GitHubRelease;
-declare function releasePR(options: ReleasePRFactoryOptions): ReleasePR;
-declare function gitHubInstance(options: GitHubFactoryOptions): GitHub;
-declare function releasePRClass(releaseType?: ReleaseType): typeof ReleasePR;
-export declare const factory: {
-    gitHubInstance: typeof gitHubInstance;
-    githubRelease: typeof githubRelease;
-    manifest: typeof manifest;
-    releasePR: typeof releasePR;
-    releasePRClass: typeof releasePRClass;
-    call: typeof call;
-    runCommand: typeof runCommand;
-};
+import { Strategy } from './strategy';
+import { GitHub } from './github';
+import { ReleaserConfig, PluginType, RepositoryConfig } from './manifest';
+import { ManifestPlugin } from './plugin';
+declare const allReleaseTypes: readonly ["dart", "elixir", "go", "go-yoshi", "helm", "java-backport", "java-bom", "java-lts", "java-yoshi", "krm-blueprint", "node", "ocaml", "php", "php-yoshi", "python", "ruby", "ruby-yoshi", "rust", "simple", "terraform-module"];
+export declare type ReleaseType = typeof allReleaseTypes[number];
+export declare function getReleaserTypes(): readonly ReleaseType[];
+export declare function getVersioningStrategyTypes(): readonly VersioningStrategyType[];
+export interface StrategyFactoryOptions extends ReleaserConfig {
+    github: GitHub;
+    path?: string;
+    targetBranch?: string;
+}
+export declare function buildStrategy(options: StrategyFactoryOptions): Promise<Strategy>;
+declare const allVersioningTypes: readonly ["default", "always-bump-patch", "service-pack"];
+export declare type VersioningStrategyType = typeof allVersioningTypes[number];
+interface PluginFactoryOptions {
+    type: PluginType;
+    github: GitHub;
+    targetBranch: string;
+    repositoryConfig: RepositoryConfig;
+    alwaysLinkLocal?: boolean;
+    updateAllPackages?: boolean;
+}
+export declare function buildPlugin(options: PluginFactoryOptions): ManifestPlugin;
 export {};