release-please 12.6.0 → 12.6.1

package/build/src/strategies/node.js

@@ -0,0 +1,82 @@
+"use strict";
+// Copyright 2019 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.Node = void 0;
+const strategy_1 = require("../strategy");
+const package_lock_json_1 = require("../updaters/node/package-lock-json");
+const samples_package_json_1 = require("../updaters/node/samples-package-json");
+const changelog_1 = require("../updaters/changelog");
+const package_json_1 = require("../updaters/node/package-json");
+class Node extends strategy_1.Strategy {
+    async buildUpdates(options) {
+        const updates = [];
+        const version = options.newVersion;
+        const packageName = this.component || '';
+        const lockFiles = ['package-lock.json', 'npm-shrinkwrap.json'];
+        lockFiles.forEach(lockFile => {
+            updates.push({
+                path: this.addPath(lockFile),
+                createIfMissing: false,
+                updater: new package_lock_json_1.PackageLockJson({
+                    version,
+                }),
+            });
+        });
+        updates.push({
+            path: this.addPath('samples/package.json'),
+            createIfMissing: false,
+            updater: new samples_package_json_1.SamplesPackageJson({
+                version,
+                packageName,
+            }),
+        });
+        updates.push({
+            path: this.addPath(this.changelogPath),
+            createIfMissing: true,
+            updater: new changelog_1.Changelog({
+                version,
+                changelogEntry: options.changelogEntry,
+            }),
+        });
+        updates.push({
+            path: this.addPath('package.json'),
+            createIfMissing: false,
+            cachedFileContents: this.pkgJsonContents,
+            updater: new package_json_1.PackageJson({
+                version,
+            }),
+        });
+        return updates;
+    }
+    async getDefaultPackageName() {
+        const pkgJsonContents = await this.getPkgJsonContents();
+        const pkg = JSON.parse(pkgJsonContents.parsedContent);
+        return pkg.name;
+    }
+    normalizeComponent(component) {
+        if (!component) {
+            return '';
+        }
+        return component.match(/^@[\w-]+\//) ? component.split('/')[1] : component;
+    }
+    async getPkgJsonContents() {
+        if (!this.pkgJsonContents) {
+            this.pkgJsonContents = await this.github.getFileContentsOnBranch(this.addPath('package.json'), this.targetBranch);
+        }
+        return this.pkgJsonContents;
+    }
+}
+exports.Node = Node;
+//# sourceMappingURL=node.js.map

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

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

package/build/src/strategies/ocaml.js

@@ -0,0 +1,75 @@
+"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.OCaml = void 0;
+// Generic
+const changelog_1 = require("../updaters/changelog");
+// OCaml
+const opam_1 = require("../updaters/ocaml/opam");
+const esy_json_1 = require("../updaters/ocaml/esy-json");
+const dune_project_1 = require("../updaters/ocaml/dune-project");
+const strategy_1 = require("../strategy");
+const notEsyLock = (path) => !path.startsWith('esy.lock');
+class OCaml extends strategy_1.Strategy {
+    async buildUpdates(options) {
+        const updates = [];
+        const version = options.newVersion;
+        updates.push({
+            path: this.addPath(this.changelogPath),
+            createIfMissing: true,
+            updater: new changelog_1.Changelog({
+                version,
+                changelogEntry: options.changelogEntry,
+            }),
+        });
+        const jsonPaths = await this.github.findFilesByExtension('json', this.path);
+        for (const path of jsonPaths) {
+            if (notEsyLock(path)) {
+                const contents = await this.github.getFileContents(this.addPath(path));
+                const pkg = JSON.parse(contents.parsedContent);
+                if (pkg.version !== undefined) {
+                    updates.push({
+                        path: this.addPath(path),
+                        createIfMissing: false,
+                        cachedFileContents: contents,
+                        updater: new esy_json_1.EsyJson({
+                            version,
+                        }),
+                    });
+                }
+            }
+        }
+        const opamPaths = await this.github.findFilesByExtension('opam', this.path);
+        opamPaths.filter(notEsyLock).forEach(path => {
+            updates.push({
+                path: this.addPath(path),
+                createIfMissing: false,
+                updater: new opam_1.Opam({
+                    version,
+                }),
+            });
+        });
+        updates.push({
+            path: this.addPath('dune-project'),
+            createIfMissing: false,
+            updater: new dune_project_1.DuneProject({
+                version,
+            }),
+        });
+        return updates;
+    }
+}
+exports.OCaml = OCaml;
+//# sourceMappingURL=ocaml.js.map

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

@@ -0,0 +1,10 @@
+import { Strategy, BuildUpdatesOptions, StrategyOptions } from '../strategy';
+import { Update } from '../update';
+import { Commit } from '../commit';
+import { Release } from '../release';
+import { ReleasePullRequest } from '../release-pull-request';
+export declare class PHPYoshi extends Strategy {
+    constructor(options: StrategyOptions);
+    buildReleasePullRequest(commits: Commit[], latestRelease?: Release, draft?: boolean, labels?: string[]): Promise<ReleasePullRequest>;
+    protected buildUpdates(options: BuildUpdatesOptions): Promise<Update[]>;
+}

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

@@ -0,0 +1,214 @@
+"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.PHPYoshi = void 0;
+const strategy_1 = require("../strategy");
+const changelog_1 = require("../updaters/changelog");
+const root_composer_update_packages_1 = require("../updaters/php/root-composer-update-packages");
+const php_manifest_1 = require("../updaters/php/php-manifest");
+const php_client_version_1 = require("../updaters/php/php-client-version");
+const version_1 = require("../version");
+const commit_1 = require("../commit");
+const commit_split_1 = require("../util/commit-split");
+const default_1 = require("../updaters/default");
+const logger_1 = require("../util/logger");
+const tag_name_1 = require("../util/tag-name");
+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 CHANGELOG_SECTIONS = [
+    { type: 'feat', section: 'Features' },
+    { type: 'fix', section: 'Bug Fixes' },
+    { type: 'perf', section: 'Performance Improvements' },
+    { type: 'revert', section: 'Reverts' },
+    { type: 'docs', section: 'Documentation' },
+    { type: 'chore', section: 'Miscellaneous Chores' },
+    { type: 'style', section: 'Styles', hidden: true },
+    { type: 'refactor', section: 'Code Refactoring', hidden: true },
+    { type: 'test', section: 'Tests', hidden: true },
+    { type: 'build', section: 'Build System', hidden: true },
+    { type: 'ci', section: 'Continuous Integration', hidden: true },
+];
+class PHPYoshi extends strategy_1.Strategy {
+    constructor(options) {
+        super({
+            ...options,
+            changelogSections: CHANGELOG_SECTIONS,
+        });
+    }
+    async buildReleasePullRequest(commits, latestRelease, draft, labels = []) {
+        var _a, _b, _c;
+        const conventionalCommits = this.postProcessCommits(commit_1.parseConventionalCommits(commits));
+        const newVersion = latestRelease
+            ? await this.versioningStrategy.bump(latestRelease.tag.version, conventionalCommits)
+            : this.initialReleaseVersion();
+        const cs = new commit_split_1.CommitSplit();
+        const splitCommits = cs.split(conventionalCommits);
+        const topLevelDirectories = Object.keys(splitCommits).sort();
+        const versionsMap = new Map();
+        const directoryVersionContents = {};
+        const component = await this.getComponent();
+        const newVersionTag = new tag_name_1.TagName(newVersion, component);
+        let releaseNotesBody = `## ${newVersion.toString()}`;
+        for (const directory of topLevelDirectories) {
+            try {
+                const contents = await this.github.getFileContentsOnBranch(this.addPath(`${directory}/VERSION`), this.targetBranch);
+                const version = version_1.Version.parse(contents.parsedContent);
+                const composer = await this.github.getFileJson(this.addPath(`${directory}/composer.json`), this.targetBranch);
+                directoryVersionContents[directory] = {
+                    versionContents: contents,
+                    composer,
+                };
+                const newVersion = await this.versioningStrategy.bump(version, splitCommits[directory]);
+                versionsMap.set(composer.name, newVersion);
+                const partialReleaseNotes = await this.changelogNotes.buildNotes(splitCommits[directory], {
+                    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,
+                });
+                releaseNotesBody = updatePHPChangelogEntry(`${composer.name} ${newVersion.toString()}`, releaseNotesBody, partialReleaseNotes);
+            }
+            catch (err) {
+                if (err.status === 404) {
+                    // if the updated path has no VERSION, assume this isn't a
+                    // module that needs updating.
+                    continue;
+                }
+                else {
+                    throw err;
+                }
+            }
+        }
+        const pullRequestTitle = pull_request_title_1.PullRequestTitle.ofComponentTargetBranchVersion(component || '', this.targetBranch, newVersion);
+        const branchName = component
+            ? branch_name_1.BranchName.ofComponentTargetBranch(component, this.targetBranch)
+            : branch_name_1.BranchName.ofTargetBranch(this.targetBranch);
+        const updates = await this.buildUpdates({
+            changelogEntry: releaseNotesBody,
+            newVersion,
+            versionsMap,
+            latestVersion: latestRelease === null || latestRelease === void 0 ? void 0 : latestRelease.tag.version,
+        });
+        for (const directory in directoryVersionContents) {
+            const componentInfo = directoryVersionContents[directory];
+            const version = versionsMap.get(componentInfo.composer.name);
+            if (!version) {
+                logger_1.logger.warn(`No version found for ${componentInfo.composer.name}`);
+                continue;
+            }
+            updates.push({
+                path: this.addPath(`${directory}/VERSION`),
+                createIfMissing: false,
+                cachedFileContents: componentInfo.versionContents,
+                updater: new default_1.DefaultUpdater({
+                    version,
+                }),
+            });
+            if ((_c = (_b = componentInfo.composer.extra) === null || _b === void 0 ? void 0 : _b.component) === null || _c === void 0 ? void 0 : _c.entry) {
+                updates.push({
+                    path: this.addPath(`${directory}/${componentInfo.composer.extra.component.entry}`),
+                    createIfMissing: false,
+                    updater: new php_client_version_1.PHPClientVersion({
+                        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,
+        };
+    }
+    async buildUpdates(options) {
+        const updates = [];
+        const version = options.newVersion;
+        const versionsMap = options.versionsMap;
+        updates.push({
+            path: this.addPath(this.changelogPath),
+            createIfMissing: true,
+            updater: new changelog_1.Changelog({
+                version,
+                changelogEntry: options.changelogEntry,
+            }),
+        });
+        // update the aggregate package information in the root
+        // composer.json and manifest.json.
+        updates.push({
+            path: this.addPath('composer.json'),
+            createIfMissing: false,
+            updater: new root_composer_update_packages_1.RootComposerUpdatePackages({
+                version,
+                versionsMap,
+            }),
+        });
+        updates.push({
+            path: this.addPath('docs/manifest.json'),
+            createIfMissing: false,
+            updater: new php_manifest_1.PHPManifest({
+                version,
+                versionsMap,
+            }),
+        });
+        updates.push({
+            path: this.addPath('src/Version.php'),
+            createIfMissing: false,
+            updater: new php_client_version_1.PHPClientVersion({
+                version,
+                versionsMap,
+            }),
+        });
+        updates.push({
+            path: this.addPath('src/ServiceBuilder.php'),
+            createIfMissing: false,
+            updater: new php_client_version_1.PHPClientVersion({
+                version,
+                versionsMap,
+            }),
+        });
+        return updates;
+    }
+}
+exports.PHPYoshi = PHPYoshi;
+function updatePHPChangelogEntry(pkgKey, changelogEntry, entryUpdate) {
+    // Remove the first line of the entry, in favor of <summary>.
+    // This also allows us to use the same regex for extracting release
+    // notes (since the string "## v0.0.0" doesn't show up multiple times).
+    const entryUpdateSplit = entryUpdate.split(/\r?\n/);
+    entryUpdateSplit.shift();
+    entryUpdate = entryUpdateSplit.join('\n');
+    return `${changelogEntry}
+
+<details><summary>${pkgKey}</summary>
+
+${entryUpdate}
+
+</details>`;
+}
+//# sourceMappingURL=php-yoshi.js.map

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

@@ -0,0 +1,6 @@
+import { Strategy, BuildUpdatesOptions, StrategyOptions } from '../strategy';
+import { Update } from '../update';
+export declare class PHP extends Strategy {
+    constructor(options: StrategyOptions);
+    protected buildUpdates(options: BuildUpdatesOptions): Promise<Update[]>;
+}

package/build/src/strategies/php.js

@@ -0,0 +1,67 @@
+"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.PHP = void 0;
+// Generic
+const changelog_1 = require("../updaters/changelog");
+// PHP Specific.
+const root_composer_update_packages_1 = require("../updaters/php/root-composer-update-packages");
+const strategy_1 = require("../strategy");
+const CHANGELOG_SECTIONS = [
+    { type: 'feat', section: 'Features' },
+    { type: 'fix', section: 'Bug Fixes' },
+    { type: 'perf', section: 'Performance Improvements' },
+    { type: 'revert', section: 'Reverts' },
+    { type: 'chore', section: 'Miscellaneous Chores' },
+    { type: 'docs', section: 'Documentation', hidden: true },
+    { type: 'style', section: 'Styles', hidden: true },
+    { type: 'refactor', section: 'Code Refactoring', hidden: true },
+    { type: 'test', section: 'Tests', hidden: true },
+    { type: 'build', section: 'Build System', hidden: true },
+    { type: 'ci', section: 'Continuous Integration', hidden: true },
+];
+class PHP extends strategy_1.Strategy {
+    constructor(options) {
+        var _a;
+        options.changelogSections = (_a = options.changelogSections) !== null && _a !== void 0 ? _a : CHANGELOG_SECTIONS;
+        super(options);
+    }
+    async buildUpdates(options) {
+        const updates = [];
+        const version = options.newVersion;
+        const versionsMap = new Map();
+        versionsMap.set('version', version);
+        updates.push({
+            path: this.addPath(this.changelogPath),
+            createIfMissing: true,
+            updater: new changelog_1.Changelog({
+                version,
+                changelogEntry: options.changelogEntry,
+            }),
+        });
+        // update composer.json
+        updates.push({
+            path: this.addPath('composer.json'),
+            createIfMissing: false,
+            updater: new root_composer_update_packages_1.RootComposerUpdatePackages({
+                version,
+                versionsMap,
+            }),
+        });
+        return updates;
+    }
+}
+exports.PHP = PHP;
+//# sourceMappingURL=php.js.map

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

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

package/build/src/strategies/python.js

@@ -0,0 +1,117 @@
+"use strict";
+// Copyright 2019 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.Python = void 0;
+const strategy_1 = require("../strategy");
+const changelog_1 = require("../updaters/changelog");
+const version_1 = require("../version");
+const setup_cfg_1 = require("../updaters/python/setup-cfg");
+const setup_py_1 = require("../updaters/python/setup-py");
+const pyproject_toml_1 = require("../updaters/python/pyproject-toml");
+const logger_1 = require("../util/logger");
+const python_file_with_version_1 = require("../updaters/python/python-file-with-version");
+class Python extends strategy_1.Strategy {
+    async buildUpdates(options) {
+        var _a;
+        const updates = [];
+        const version = options.newVersion;
+        updates.push({
+            path: this.addPath(this.changelogPath),
+            createIfMissing: true,
+            updater: new changelog_1.Changelog({
+                version,
+                changelogEntry: options.changelogEntry,
+            }),
+        });
+        updates.push({
+            path: this.addPath('setup.cfg'),
+            createIfMissing: false,
+            updater: new setup_cfg_1.SetupCfg({
+                version,
+            }),
+        });
+        updates.push({
+            path: this.addPath('setup.py'),
+            createIfMissing: false,
+            updater: new setup_py_1.SetupPy({
+                version,
+            }),
+        });
+        const parsedPyProject = await this.getPyProject(this.addPath('pyproject.toml'));
+        const pyProject = (parsedPyProject === null || parsedPyProject === void 0 ? void 0 : parsedPyProject.project) || ((_a = parsedPyProject === null || parsedPyProject === void 0 ? void 0 : parsedPyProject.tool) === null || _a === void 0 ? void 0 : _a.poetry);
+        let projectName = this.component;
+        if (pyProject) {
+            updates.push({
+                path: this.addPath('pyproject.toml'),
+                createIfMissing: false,
+                updater: new pyproject_toml_1.PyProjectToml({
+                    version,
+                }),
+            });
+            projectName = pyProject.name;
+        }
+        else {
+            logger_1.logger.warn(parsedPyProject
+                ? 'invalid pyproject.toml'
+                : `file ${this.addPath('pyproject.toml')} did not exist`);
+        }
+        if (!projectName) {
+            logger_1.logger.warn('No project/component found.');
+        }
+        else {
+            updates.push({
+                path: this.addPath(`${projectName}/__init__.py`),
+                createIfMissing: false,
+                updater: new python_file_with_version_1.PythonFileWithVersion({
+                    version,
+                }),
+            });
+            updates.push({
+                path: this.addPath(`src/${projectName}/__init__.py`),
+                createIfMissing: false,
+                updater: new python_file_with_version_1.PythonFileWithVersion({
+                    version,
+                }),
+            });
+        }
+        // There should be only one version.py, but foreach in case that is incorrect
+        const versionPyFilesSearch = this.github.findFilesByFilename('version.py', this.path);
+        const versionPyFiles = await versionPyFilesSearch;
+        versionPyFiles.forEach(path => {
+            updates.push({
+                path: this.addPath(path),
+                createIfMissing: false,
+                updater: new python_file_with_version_1.PythonFileWithVersion({
+                    version,
+                }),
+            });
+        });
+        return updates;
+    }
+    async getPyProject(path) {
+        try {
+            const content = await this.github.getFileContentsOnBranch(path, this.targetBranch);
+            return pyproject_toml_1.parsePyProject(content.parsedContent);
+        }
+        catch (e) {
+            return null;
+        }
+    }
+    initialReleaseVersion() {
+        return version_1.Version.parse('0.1.0');
+    }
+}
+exports.Python = Python;
+//# sourceMappingURL=python.js.map

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

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