release-please 12.5.0 → 13.0.0-candidate.2

package/build/src/factory.js

@@ -13,170 +13,180 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.factory = void 0;
+exports.buildPlugin = exports.buildStrategy = exports.getVersioningStrategyTypes = exports.getReleaserTypes = void 0;
+const go_1 = require("./strategies/go");
+const go_yoshi_1 = require("./strategies/go-yoshi");
+const java_yoshi_1 = require("./strategies/java-yoshi");
+const krm_blueprint_1 = require("./strategies/krm-blueprint");
+const ocaml_1 = require("./strategies/ocaml");
+const php_1 = require("./strategies/php");
+const php_yoshi_1 = require("./strategies/php-yoshi");
+const python_1 = require("./strategies/python");
+const ruby_1 = require("./strategies/ruby");
+const ruby_yoshi_1 = require("./strategies/ruby-yoshi");
+const rust_1 = require("./strategies/rust");
+const simple_1 = require("./strategies/simple");
+const terraform_module_1 = require("./strategies/terraform-module");
+const helm_1 = require("./strategies/helm");
+const elixir_1 = require("./strategies/elixir");
+const dart_1 = require("./strategies/dart");
+const node_1 = require("./strategies/node");
+const default_1 = require("./versioning-strategies/default");
+const always_bump_patch_1 = require("./versioning-strategies/always-bump-patch");
+const service_pack_1 = require("./versioning-strategies/service-pack");
+const dependency_manifest_1 = require("./versioning-strategies/dependency-manifest");
+const node_workspace_1 = require("./plugins/node-workspace");
+const cargo_workspace_1 = require("./plugins/cargo-workspace");
 // Factory shared by GitHub Action and CLI for creating Release PRs
 // and GitHub Releases:
-const release_pr_1 = require("./release-pr");
-const github_release_1 = require("./github-release");
-const releasers_1 = require("./releasers");
-const github_1 = require("./github");
-const constants_1 = require("./constants");
-const manifest_1 = require("./manifest");
-// eslint-disable-next-line @typescript-eslint/no-var-requires
-const parseGithubRepoUrl = require('parse-github-repo-url');
-function isManifestCmd(cmdOpts) {
-    const { command, options } = cmdOpts;
-    return ((command === 'manifest-pr' || command === 'manifest-release') &&
-        typeof options === 'object');
-}
-function isGitHubReleaseCmd(cmdOpts) {
-    const { command, options } = cmdOpts;
-    return command === 'github-release' && typeof options === 'object';
+// add any new releasers you create to this type as well as the `releasers`
+// object below.
+const allReleaseTypes = [
+    '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',
+];
+const releasers = {
+    go: options => new go_1.Go(options),
+    'go-yoshi': options => new go_yoshi_1.GoYoshi(options),
+    'krm-blueprint': options => new krm_blueprint_1.KRMBlueprint(options),
+    node: options => new node_1.Node(options),
+    ocaml: options => new ocaml_1.OCaml(options),
+    php: options => new php_1.PHP(options),
+    'php-yoshi': options => new php_yoshi_1.PHPYoshi(options),
+    python: options => new python_1.Python(options),
+    rust: options => new rust_1.Rust(options),
+    simple: options => new simple_1.Simple(options),
+    'terraform-module': options => new terraform_module_1.TerraformModule(options),
+    helm: options => new helm_1.Helm(options),
+    elixir: options => new elixir_1.Elixir(options),
+    dart: options => new dart_1.Dart(options),
+};
+function getReleaserTypes() {
+    return allReleaseTypes;
 }
-function isReleasePRCmd(cmdOpts) {
-    const { command, options } = cmdOpts;
-    return ((command === 'release-pr' || command === 'latest-tag') &&
-        typeof options === 'object');
+exports.getReleaserTypes = getReleaserTypes;
+function getVersioningStrategyTypes() {
+    return allVersioningTypes;
 }
-function runCommand(command, options) {
-    const errMsg = `Invalid command(${command}) with options(${JSON.stringify(options)})`;
-    let result;
-    const cmdOpts = { command, options };
-    if (isManifestCmd(cmdOpts)) {
-        const m = manifest(cmdOpts.options);
-        if (cmdOpts.command === 'manifest-pr') {
-            result = exports.factory.call(m, 'pullRequest');
+exports.getVersioningStrategyTypes = getVersioningStrategyTypes;
+async function buildStrategy(options) {
+    var _a;
+    const targetBranch = (_a = options.targetBranch) !== null && _a !== void 0 ? _a : options.github.repository.defaultBranch;
+    const versioningStrategy = buildVersioningStrategy({
+        type: options.versioning,
+        bumpMinorPreMajor: options.bumpMinorPreMajor,
+        bumpPatchForMinorPreMajor: options.bumpPatchForMinorPreMajor,
+    });
+    const strategyOptions = {
+        github: options.github,
+        targetBranch,
+        path: options.path,
+        bumpMinorPreMajor: options.bumpMinorPreMajor,
+        bumpPatchForMinorPreMajor: options.bumpPatchForMinorPreMajor,
+        component: options.component,
+        packageName: options.packageName,
+        changelogPath: options.changelogPath,
+        changelogSections: options.changelogSections,
+        versioningStrategy,
+        skipGitHubRelease: options.skipGithubRelease,
+        releaseAs: options.releaseAs,
+        includeComponentInTag: options.includeComponentInTag,
+    };
+    switch (options.releaseType) {
+        case 'ruby': {
+            return new ruby_1.Ruby({
+                ...strategyOptions,
+                versionFile: options.versionFile,
+            });
         }
-        else if (cmdOpts.command === 'manifest-release') {
-            result = exports.factory.call(m, 'githubRelease');
+        case 'ruby-yoshi': {
+            return new ruby_yoshi_1.RubyYoshi({
+                ...strategyOptions,
+                versionFile: options.versionFile,
+            });
         }
-        else {
-            throw new Error(errMsg);
+        case 'java-yoshi': {
+            return new java_yoshi_1.JavaYoshi({
+                ...strategyOptions,
+                extraFiles: options.extraFiles,
+            });
         }
-    }
-    else if (isGitHubReleaseCmd(cmdOpts)) {
-        result = exports.factory.call(githubRelease(cmdOpts.options), 'run');
-    }
-    else if (isReleasePRCmd(cmdOpts)) {
-        const releasePr = releasePR(cmdOpts.options);
-        if (cmdOpts.command === 'release-pr') {
-            result = exports.factory.call(releasePr, 'run');
+        case 'java-backport': {
+            return new java_yoshi_1.JavaYoshi({
+                ...strategyOptions,
+                extraFiles: options.extraFiles,
+                versioningStrategy: new always_bump_patch_1.AlwaysBumpPatch(),
+            });
         }
-        else if (cmdOpts.command === 'latest-tag') {
-            result = exports.factory.call(releasePr, 'latestTag');
+        case 'java-bom': {
+            return new java_yoshi_1.JavaYoshi({
+                ...strategyOptions,
+                extraFiles: options.extraFiles,
+                versioningStrategy: new dependency_manifest_1.DependencyManifest({
+                    bumpMinorPreMajor: options.bumpMinorPreMajor,
+                    bumpPatchForMinorPreMajor: options.bumpPatchForMinorPreMajor,
+                }),
+            });
         }
-        else {
-            throw new Error(errMsg);
+        case 'java-lts': {
+            return new java_yoshi_1.JavaYoshi({
+                ...strategyOptions,
+                extraFiles: options.extraFiles,
+                versioningStrategy: new service_pack_1.ServicePackVersioningStrategy(),
+            });
+        }
+        default: {
+            const builder = releasers[options.releaseType];
+            if (builder) {
+                return builder(strategyOptions);
+            }
+            throw new Error(`Unknown release type: ${options.releaseType}`);
         }
     }
-    else {
-        throw new Error(errMsg);
-    }
-    return result;
 }
-function call(instance, method) {
-    if (!(method in instance)) {
-        throw new Error(`No such method(${method}) on ${instance.constructor.name}`);
-    }
-    let result;
-    if (instance instanceof manifest_1.Manifest) {
-        result = instance[method]();
-    }
-    else if (instance instanceof release_pr_1.ReleasePR) {
-        result = instance[method]();
-    }
-    else if (instance instanceof github_release_1.GitHubRelease) {
-        result = instance[method]();
-    }
-    else {
-        throw new Error('Unknown instance.');
+exports.buildStrategy = buildStrategy;
+const allVersioningTypes = [
+    'default',
+    'always-bump-patch',
+    'service-pack',
+];
+function buildVersioningStrategy(options) {
+    switch (options.type) {
+        case 'always-bump-patch':
+            return new always_bump_patch_1.AlwaysBumpPatch(options);
+        case 'service-pack':
+            return new service_pack_1.ServicePackVersioningStrategy(options);
+        default:
+            return new default_1.DefaultVersioningStrategy(options);
     }
-    return result;
 }
-function getLabels(label) {
-    return label ? label.split(',') : constants_1.DEFAULT_LABELS;
-}
-function getGitHubFactoryOpts(options) {
-    const { repoUrl, defaultBranch, fork, token, apiUrl, octokitAPIs, ...remaining } = options;
-    return [
-        {
-            repoUrl,
-            defaultBranch,
-            fork,
-            token,
-            apiUrl,
-            octokitAPIs,
-        },
-        remaining,
-    ];
-}
-function manifest(options) {
-    const [GHFactoryOptions, ManifestFactoryOptions] = getGitHubFactoryOpts(options);
-    const github = gitHubInstance(GHFactoryOptions);
-    return new manifest_1.Manifest({ github, ...ManifestFactoryOptions });
-}
-function githubRelease(options) {
-    const [GHFactoryOptions, GHRAndRPFactoryOptions] = getGitHubFactoryOpts(options);
-    const github = gitHubInstance(GHFactoryOptions);
-    const { releaseType, label, path, packageName, bumpMinorPreMajor, releaseAs, snapshot, monorepoTags, changelogSections, changelogPath, lastPackageVersion, versionFile, ...GHRFactoryOptions } = GHRAndRPFactoryOptions;
-    const labels = getLabels(label);
-    const releasePR = new (releasePRClass(releaseType))({
-        github,
-        labels,
-        path,
-        packageName,
-        bumpMinorPreMajor,
-        releaseAs,
-        snapshot,
-        monorepoTags,
-        changelogSections,
-        changelogPath,
-        lastPackageVersion,
-        versionFile,
-    });
-    return new github_release_1.GitHubRelease({ github, releasePR, ...GHRFactoryOptions });
-}
-function releasePR(options) {
-    const [GHFactoryOptions, RPFactoryOptions] = getGitHubFactoryOpts(options);
-    const github = gitHubInstance(GHFactoryOptions);
-    const { releaseType, label, latestTagName, latestTagSha, latestTagVersion, ...RPConstructorOptions } = RPFactoryOptions;
-    let latestTag = undefined;
-    if (latestTagName && latestTagSha && latestTagVersion) {
-        latestTag = {
-            name: latestTagName,
-            sha: latestTagSha,
-            version: latestTagVersion,
-        };
+function buildPlugin(options) {
+    switch (options.type) {
+        case 'cargo-workspace':
+            return new cargo_workspace_1.CargoWorkspace(options.github, options.targetBranch, options.repositoryConfig, options);
+        case 'node-workspace':
+            return new node_workspace_1.NodeWorkspace(options.github, options.targetBranch, options.repositoryConfig, options);
+        default:
+            throw new Error(`Unknown plugin type: ${options.type}`);
     }
-    const labels = getLabels(label);
-    return new (exports.factory.releasePRClass(releaseType))({
-        github,
-        labels,
-        latestTag,
-        ...RPConstructorOptions,
-    });
-}
-function gitHubInstance(options) {
-    const { repoUrl, ...remaining } = options;
-    const [owner, repo] = parseGithubRepoUrl(repoUrl);
-    return new github_1.GitHub({
-        owner,
-        repo,
-        ...remaining,
-    });
 }
-function releasePRClass(releaseType) {
-    const releasers = releasers_1.getReleasers();
-    const releaser = releaseType ? releasers[releaseType] : release_pr_1.ReleasePR;
-    return releaser;
-}
-exports.factory = {
-    gitHubInstance,
-    githubRelease,
-    manifest,
-    releasePR,
-    releasePRClass,
-    call,
-    runCommand,
-};
+exports.buildPlugin = buildPlugin;
 //# sourceMappingURL=factory.js.map