release-it 0.0.0-pl.0

package/lib/config.js

@@ -0,0 +1,139 @@
+import util from 'node:util';
+import { cosmiconfigSync } from 'cosmiconfig';
+import parseToml from '@iarna/toml/parse-string.js';
+import _ from 'lodash';
+import isCI from 'is-ci';
+import { readJSON, getSystemInfo } from './util.js';
+
+const debug = util.debug('release-it:config');
+const defaultConfig = readJSON(new URL('../config/release-it.json', import.meta.url));
+
+const searchPlaces = [
+  'package.json',
+  '.release-it.json',
+  '.release-it.js',
+  '.release-it.cjs',
+  '.release-it.yaml',
+  '.release-it.yml',
+  '.release-it.toml'
+];
+
+const loaders = {
+  '.toml': (_, content) => parseToml(content)
+};
+
+const getLocalConfig = ({ file, dir = process.cwd() }) => {
+  let localConfig = {};
+  if (file === false) return localConfig;
+  const explorer = cosmiconfigSync('release-it', {
+    searchPlaces,
+    loaders
+  });
+  const result = file ? explorer.load(file) : explorer.search(dir);
+  if (result && typeof result.config === 'string') {
+    throw new Error(`Invalid configuration file at ${result.filepath}`);
+  }
+  debug({ cosmiconfig: result });
+  return result && _.isPlainObject(result.config) ? result.config : localConfig;
+};
+
+class Config {
+  constructor(config = {}) {
+    this.constructorConfig = config;
+    this.localConfig = getLocalConfig({ file: config.config, dir: config.configDir });
+    this.options = this.mergeOptions();
+    this.options = this.expandPreReleaseShorthand(this.options);
+    this.contextOptions = {};
+    debug({ system: getSystemInfo() });
+    debug(this.options);
+  }
+
+  expandPreReleaseShorthand(options) {
+    const { increment, preRelease, preReleaseId, snapshot } = options;
+    const isPreRelease = Boolean(preRelease) || Boolean(snapshot);
+    const inc = snapshot ? 'prerelease' : increment;
+    const preId = typeof preRelease === 'string' ? preRelease : typeof snapshot === 'string' ? snapshot : preReleaseId;
+    options.version = {
+      increment: inc,
+      isPreRelease,
+      preReleaseId: preId
+    };
+    if (typeof snapshot === 'string' && options.git) {
+      // Pre set and hard code some options
+      options.git.tagMatch = `0.0.0-${snapshot}.[0-9]*`;
+      options.git.getLatestTagFromAllRefs = true;
+      options.git.requireBranch = '!main';
+      options.git.requireUpstream = false;
+      options.npm.ignoreVersion = true;
+    }
+    return options;
+  }
+
+  mergeOptions() {
+    return _.defaultsDeep(
+      {},
+      this.constructorConfig,
+      {
+        ci: isCI
+      },
+      this.localConfig,
+      this.defaultConfig
+    );
+  }
+
+  getContext(path) {
+    const context = _.merge({}, this.options, this.contextOptions);
+    return path ? _.get(context, path) : context;
+  }
+
+  setContext(options) {
+    debug(options);
+    _.merge(this.contextOptions, options);
+  }
+
+  setCI(value = true) {
+    this.options.ci = value;
+  }
+
+  get defaultConfig() {
+    return defaultConfig;
+  }
+
+  get isDryRun() {
+    return Boolean(this.options['dry-run']);
+  }
+
+  get isIncrement() {
+    return this.options.increment !== false;
+  }
+
+  get isVerbose() {
+    return Boolean(this.options.verbose);
+  }
+
+  get verbosityLevel() {
+    return this.options.verbose;
+  }
+
+  get isDebug() {
+    return debug.enabled;
+  }
+
+  get isCI() {
+    return Boolean(this.options.ci) || this.isReleaseVersion || this.isChangelog;
+  }
+
+  get isPromptOnlyVersion() {
+    return this.options['only-version'];
+  }
+
+  get isReleaseVersion() {
+    return Boolean(this.options['release-version']);
+  }
+
+  get isChangelog() {
+    return Boolean(this.options['changelog']);
+  }
+}
+
+export default Config;

package/lib/index.js

@@ -0,0 +1,152 @@
+import _ from 'lodash';
+import { getPlugins } from './plugin/factory.js';
+import Logger from './log.js';
+import Config from './config.js';
+import Shell from './shell.js';
+import Prompt from './prompt.js';
+import Spinner from './spinner.js';
+import { reduceUntil, parseVersion } from './util.js';
+
+const runTasks = async (opts, di) => {
+  let container = {};
+
+  try {
+    Object.assign(container, di);
+    container.config = container.config || new Config(opts);
+
+    const { config } = container;
+    const { isCI, isVerbose, verbosityLevel, isDryRun, isChangelog, isReleaseVersion } = config;
+
+    container.log = container.log || new Logger({ isCI, isVerbose, verbosityLevel, isDryRun });
+    container.spinner = container.spinner || new Spinner({ container, config });
+    container.prompt = container.prompt || new Prompt({ container: { config } });
+    container.shell = container.shell || new Shell({ container });
+
+    const { log, shell, spinner } = container;
+
+    const options = config.getContext();
+
+    const { hooks } = options;
+
+    const runHook = async (...name) => {
+      const scripts = hooks[name.join(':')];
+      if (!scripts || !scripts.length) return;
+      const context = config.getContext();
+      const external = true;
+      for (const script of _.castArray(scripts)) {
+        const task = () => shell.exec(script, { external }, context);
+        await spinner.show({ task, label: script, context, external });
+      }
+    };
+
+    const runLifeCycleHook = async (plugin, name, ...args) => {
+      if (plugin === _.first(plugins)) await runHook('before', name);
+      await runHook('before', plugin.namespace, name);
+      const willHookRun = (await plugin[name](...args)) !== false;
+      if (willHookRun) {
+        await runHook('after', plugin.namespace, name);
+      }
+      if (plugin === _.last(plugins)) await runHook('after', name);
+    };
+
+    const [internal, external] = await getPlugins(config, container);
+    let plugins = [...external, ...internal];
+
+    for (const plugin of plugins) {
+      await runLifeCycleHook(plugin, 'init');
+    }
+
+    const { increment, isPreRelease, preReleaseId } = options.version;
+
+    const name = await reduceUntil(plugins, plugin => plugin.getName());
+    const latestVersion = (await reduceUntil(plugins, plugin => plugin.getLatestVersion())) || '0.0.0';
+    const changelog = await reduceUntil(plugins, plugin => plugin.getChangelog(latestVersion));
+
+    if (isChangelog) {
+      console.log(changelog);
+      process.exit(0);
+    }
+
+    const incrementBase = { latestVersion, increment, isPreRelease, preReleaseId };
+
+    const { snapshot } = config.options;
+    if (snapshot && (!incrementBase.latestVersion.startsWith('0.0.0') || incrementBase.latestVersion === '0.0.0')) {
+      // Reading the latest version first allows to increment the final counter, fake it if it's not a snapshot:
+      incrementBase.latestVersion = `0.0.0-0`;
+    }
+
+    let version;
+    if (config.isIncrement) {
+      incrementBase.increment = await reduceUntil(plugins, plugin => plugin.getIncrement(incrementBase));
+      version = await reduceUntil(plugins, plugin => plugin.getIncrementedVersionCI(incrementBase));
+    } else {
+      version = latestVersion;
+    }
+
+    config.setContext({ name, latestVersion, version, changelog });
+
+    if (!isReleaseVersion) {
+      const action = config.isIncrement ? 'release' : 'update';
+      const suffix = version && config.isIncrement ? `${latestVersion}...${version}` : `currently at ${latestVersion}`;
+      log.obtrusive(`🚀 Let's ${action} ${name} (${suffix})`);
+      log.preview({ title: 'changelog', text: changelog });
+    }
+
+    if (config.isIncrement) {
+      version = version || (await reduceUntil(plugins, plugin => plugin.getIncrementedVersion(incrementBase)));
+    }
+
+    if (!version) {
+      log.obtrusive(`No new version to release`);
+    }
+
+    if (isReleaseVersion) {
+      console.log(version);
+      process.exit(0);
+    }
+
+    if (version) {
+      config.setContext(parseVersion(version));
+
+      if (config.isPromptOnlyVersion) {
+        config.setCI(true);
+      }
+
+      for (const hook of ['beforeBump', 'bump', 'beforeRelease']) {
+        for (const plugin of plugins) {
+          const args = hook === 'bump' ? [version] : [];
+          await runLifeCycleHook(plugin, hook, ...args);
+        }
+      }
+
+      plugins = [...internal, ...external];
+
+      for (const hook of ['release', 'afterRelease']) {
+        for (const plugin of plugins) {
+          await runLifeCycleHook(plugin, hook);
+        }
+      }
+    }
+
+    log.log(`🏁 Done (in ${Math.floor(process.uptime())}s.)`);
+
+    return {
+      name,
+      changelog,
+      latestVersion,
+      version
+    };
+  } catch (err) {
+    const { log } = container;
+    log ? log.error(err.message || err) : console.error(err); // eslint-disable-line no-console
+    throw err;
+  }
+};
+
+export default runTasks;
+
+/** @public  */
+export { default as Config } from './config.js';
+
+/** @public  */
+export { default as Plugin } from './plugin/Plugin.js';

package/lib/log.js

@@ -0,0 +1,69 @@
+import { EOL } from 'node:os';
+import chalk from 'chalk';
+import _ from 'lodash';
+
+const { isObject, last, filter, isString, lowerCase, upperFirst, isArray } = _;
+
+class Logger {
+  constructor({ isCI = true, isVerbose = false, verbosityLevel = 0, isDryRun = false } = {}) {
+    this.isCI = isCI;
+    this.isVerbose = isVerbose;
+    this.verbosityLevel = verbosityLevel;
+    this.isDryRun = isDryRun;
+  }
+
+  shouldLog(isExternal) {
+    return this.verbosityLevel === 2 || (this.isVerbose && isExternal);
+  }
+
+  log(...args) {
+    console.log(...args); // eslint-disable-line no-console
+  }
+
+  error(...args) {
+    console.error(chalk.red('ERROR'), ...args); // eslint-disable-line no-console
+  }
+
+  info(...args) {
+    this.log(chalk.grey(...args));
+  }
+
+  warn(...args) {
+    this.log(chalk.yellow('WARNING'), ...args);
+  }
+
+  verbose(...args) {
+    const { isExternal } = isObject(last(args)) ? last(args) : {};
+    if (this.shouldLog(isExternal)) {
+      this.log(...filter(args, isString));
+    }
+  }
+
+  exec(...args) {
+    const { isDryRun: isExecutedInDryRun, isExternal, isCached } = isObject(last(args)) ? last(args) : {};
+    if (this.shouldLog(isExternal) || this.isDryRun) {
+      const prefix = isExecutedInDryRun == null ? '$' : '!';
+      const command = args.map(cmd => (isString(cmd) ? cmd : isArray(cmd) ? cmd.join(' ') : '')).join(' ');
+      const message = [prefix, command, isCached ? '[cached]' : ''].join(' ').trim();
+      this.log(message);
+    }
+  }
+
+  obtrusive(...args) {
+    if (!this.isCI) this.log();
+    this.log(...args);
+    if (!this.isCI) this.log();
+  }
+
+  preview({ title, text }) {
+    if (text) {
+      const header = chalk.bold(upperFirst(title));
+      const body = text.replace(new RegExp(EOL + EOL, 'g'), EOL);
+      this.obtrusive(`${header}:${EOL}${body}`);
+    } else {
+      this.obtrusive(`Empty ${lowerCase(title)}`);
+    }
+  }
+}
+
+export default Logger;

package/lib/plugin/GitBase.js

@@ -0,0 +1,125 @@
+import { EOL } from 'node:os';
+import { format, parseGitUrl } from '../util.js';
+import Plugin from './Plugin.js';
+
+const options = { write: false };
+const changelogFallback = 'git log --pretty=format:"* %s (%h)"';
+
+class GitBase extends Plugin {
+  async init() {
+    const remoteUrl = await this.getRemoteUrl();
+    await this.fetch(remoteUrl);
+
+    const branchName = await this.getBranchName();
+    const repo = parseGitUrl(remoteUrl);
+    this.setContext({ remoteUrl, branchName, repo });
+    this.config.setContext({ remoteUrl, branchName, repo });
+
+    const latestTag = await this.getLatestTagName();
+    const secondLatestTag = !this.config.isIncrement ? await this.getSecondLatestTagName(latestTag) : null;
+    const tagTemplate = this.options.tagName || ((latestTag || '').match(/^v/) ? 'v${version}' : '${version}');
+    this.config.setContext({ latestTag, secondLatestTag, tagTemplate });
+  }
+
+  getName() {
+    return this.getContext('repo.project');
+  }
+
+  getLatestVersion() {
+    const { tagTemplate, latestTag } = this.config.getContext();
+    const prefix = tagTemplate.replace(/\$\{version\}/, '');
+    return latestTag ? latestTag.replace(prefix, '').replace(/^v/, '') : null;
+  }
+
+  async getChangelog() {
+    const { snapshot } = this.config.getContext();
+    const { latestTag, secondLatestTag } = this.config.getContext();
+    const context = { latestTag, from: latestTag, to: 'HEAD' };
+    const { changelog } = this.options;
+    if (!changelog) return null;
+
+    if (latestTag && !this.config.isIncrement) {
+      context.from = secondLatestTag;
+      context.to = `${latestTag}^1`;
+    }
+
+    // For now, snapshots do not get a changelog, as it often goes haywire (easy to add to release manually)
+    if (snapshot) return '';
+
+    if (!context.from && changelog.includes('${from}')) {
+      return this.exec(changelogFallback);
+    }
+
+    return this.exec(changelog, { context, options });
+  }
+
+  bump(version) {
+    const { tagTemplate } = this.config.getContext();
+    const context = Object.assign(this.config.getContext(), { version });
+    const tagName = format(tagTemplate, context) || version;
+    this.setContext({ version });
+    this.config.setContext({ tagName });
+  }
+
+  isRemoteName(remoteUrlOrName) {
+    return remoteUrlOrName && !remoteUrlOrName.includes('/');
+  }
+
+  async getRemoteUrl() {
+    const remoteNameOrUrl = this.options.pushRepo || (await this.getRemote()) || 'origin';
+    return this.isRemoteName(remoteNameOrUrl)
+      ? this.exec(`git remote get-url ${remoteNameOrUrl}`, { options }).catch(() =>
+          this.exec(`git config --get remote.${remoteNameOrUrl}.url`, { options }).catch(() => null)
+        )
+      : remoteNameOrUrl;
+  }
+
+  async getRemote() {
+    const branchName = await this.getBranchName();
+    return branchName ? await this.getRemoteForBranch(branchName) : null;
+  }
+
+  getBranchName() {
+    return this.exec('git rev-parse --abbrev-ref HEAD', { options }).catch(() => null);
+  }
+
+  getRemoteForBranch(branch) {
+    return this.exec(`git config --get branch.${branch}.remote`, { options }).catch(() => null);
+  }
+
+  fetch(remoteUrl) {
+    return this.exec('git fetch').catch(err => {
+      this.debug(err);
+      throw new Error(`Unable to fetch from ${remoteUrl}${EOL}${err.message}`);
+    });
+  }
+
+  getLatestTagName() {
+    const context = Object.assign({}, this.config.getContext(), { version: '*' });
+    const match = format(this.options.tagMatch || this.options.tagName || '${version}', context);
+    const exclude = this.options.tagExclude ? ` --exclude=${format(this.options.tagExclude, context)}` : '';
+    if (this.options.getLatestTagFromAllRefs) {
+      return this.exec(
+        `git -c "versionsort.suffix=-" for-each-ref --count=1 --sort=-v:refname --format="%(refname:short)" refs/tags/${match}`,
+        { options }
+      ).then(
+        stdout => stdout || null,
+        () => null
+      );
+    } else {
+      return this.exec(`git describe --tags --match=${match} --abbrev=0${exclude}`, { options }).then(
+        stdout => stdout || null,
+        () => null
+      );
+    }
+  }
+
+  async getSecondLatestTagName(latestTag) {
+    const sha = await this.exec(`git rev-list ${latestTag || '--skip=1'} --tags --max-count=1`, {
+      options
+    });
+    return this.exec(`git describe --tags --abbrev=0 "${sha}^"`, { options }).catch(() => null);
+  }
+}
+
+export default GitBase;

package/lib/plugin/GitRelease.js

@@ -0,0 +1,58 @@
+import _ from 'lodash';
+import { readJSON } from '../util.js';
+import GitBase from './GitBase.js';
+
+const defaultConfig = readJSON(new URL('../../config/release-it.json', import.meta.url));
+
+class GitRelease extends GitBase {
+  static isEnabled(options) {
+    return options.release;
+  }
+
+  getInitialOptions(options) {
+    const baseOptions = super.getInitialOptions(...arguments);
+    const git = options.git || defaultConfig.git;
+    const gitOptions = _.pick(git, [
+      'tagExclude',
+      'tagName',
+      'tagMatch',
+      'getLatestTagFromAllRefs',
+      'pushRepo',
+      'changelog'
+    ]);
+    return _.defaults(baseOptions, gitOptions);
+  }
+
+  get token() {
+    const { tokenRef } = this.options;
+    return _.get(process.env, tokenRef, null);
+  }
+
+  async beforeRelease() {
+    const { releaseNotes: script } = this.options;
+    const { changelog } = this.config.getContext();
+    const releaseNotes = script ? await this.processReleaseNotes(script) : changelog;
+    this.setContext({ releaseNotes });
+    if (releaseNotes !== changelog) {
+      this.log.preview({ title: 'release notes', text: releaseNotes });
+    }
+  }
+
+  async processReleaseNotes(script) {
+    if (typeof script === 'function') {
+      const ctx = Object.assign({}, this.config.getContext(), { [this.namespace]: this.getContext() });
+      return script(ctx);
+    } else {
+      return this.exec(script);
+    }
+  }
+
+  afterRelease() {
+    const { isReleased, releaseUrl } = this.getContext();
+    if (isReleased) {
+      this.log.log(`🔗 ${releaseUrl}`);
+    }
+  }
+}
+
+export default GitRelease;

package/lib/plugin/Plugin.js

@@ -0,0 +1,73 @@
+import { debug } from 'node:util';
+import _ from 'lodash';
+
+class Plugin {
+  static isEnabled() {
+    return true;
+  }
+
+  static disablePlugin() {
+    return null;
+  }
+
+  constructor({ namespace, options = {}, container = {} } = {}) {
+    this.namespace = namespace;
+    this.options = Object.freeze(this.getInitialOptions(options, namespace));
+    this.context = {};
+    this.config = container.config;
+    this.log = container.log;
+    this.shell = container.shell;
+    this.spinner = container.spinner;
+    this.prompt = container.prompt;
+    this.debug = debug(`release-it:${namespace}`);
+  }
+
+  getInitialOptions(options, namespace) {
+    return options[namespace] || {};
+  }
+
+  init() {}
+  getName() {}
+  getLatestVersion() {}
+  getChangelog() {}
+  getIncrement() {}
+  getIncrementedVersionCI() {}
+  getIncrementedVersion() {}
+  beforeBump() {}
+  bump() {}
+  beforeRelease() {}
+  release() {}
+  afterRelease() {}
+
+  getContext(path) {
+    const context = _.merge({}, this.options, this.context);
+    return path ? _.get(context, path) : context;
+  }
+
+  setContext(context) {
+    _.merge(this.context, context);
+  }
+
+  exec(command, { options, context = {} } = {}) {
+    const ctx = Object.assign(context, this.config.getContext(), { [this.namespace]: this.getContext() });
+    return this.shell.exec(command, options, ctx);
+  }
+
+  registerPrompts(prompts) {
+    this.prompt.register(prompts, this.namespace);
+  }
+
+  async showPrompt(options) {
+    options.namespace = this.namespace;
+    return this.prompt.show(options);
+  }
+
+  step(options) {
+    const context = Object.assign({}, this.config.getContext(), { [this.namespace]: this.getContext() });
+    const opts = Object.assign({}, options, { context });
+    const isException = this.config.isPromptOnlyVersion && ['incrementList', 'publish', 'otp'].includes(opts.prompt);
+    return this.config.isCI && !isException ? this.spinner.show(opts) : this.showPrompt(opts);
+  }
+}
+
+export default Plugin;

package/lib/plugin/factory.js

@@ -0,0 +1,89 @@
+import url from 'node:url';
+import path from 'node:path';
+import util from 'node:util';
+import { createRequire } from 'node:module';
+import _ from 'lodash';
+import Version from './version/Version.js';
+import Git from './git/Git.js';
+import GitLab from './gitlab/GitLab.js';
+import GitHub from './github/GitHub.js';
+import npm from './npm/npm.js';
+
+const debug = util.debug('release-it:plugins');
+
+const pluginNames = ['npm', 'git', 'github', 'gitlab', 'version'];
+
+const plugins = {
+  version: Version,
+  git: Git,
+  gitlab: GitLab,
+  github: GitHub,
+  npm: npm
+};
+
+const load = async pluginName => {
+  let plugin = null;
+  try {
+    const module = await import(pluginName);
+    plugin = module.default;
+  } catch (err) {
+    debug(err);
+    try {
+      const module = await import(path.join(process.cwd(), pluginName));
+      plugin = module.default;
+    } catch (err) {
+      debug(err);
+      // In some cases or tests we might need to support legacy `require.resolve`
+      const require = createRequire(process.cwd());
+      const module = await import(url.pathToFileURL(require.resolve(pluginName, { paths: [process.cwd()] })));
+      plugin = module.default;
+    }
+  }
+  return [getPluginName(pluginName), plugin];
+};
+
+/** @internal */
+export const getPluginName = pluginName => {
+  if (pluginName.startsWith('.')) {
+    return path.parse(pluginName).name;
+  }
+
+  return pluginName;
+};
+
+export let getPlugins = async (config, container) => {
+  const context = config.getContext();
+  const disabledPlugins = [];
+
+  const enabledExternalPlugins = await _.reduce(
+    context.plugins,
+    async (result, pluginConfig, pluginName) => {
+      const [name, Plugin] = await load(pluginName);
+      const [namespace, options] = pluginConfig.length === 2 ? pluginConfig : [name, pluginConfig];
+      config.setContext({ [namespace]: options });
+      if (await Plugin.isEnabled(options)) {
+        const instance = new Plugin({ namespace, options: config.getContext(), container });
+        debug({ namespace, options: instance.options });
+        (await result).push(instance);
+        disabledPlugins.push(..._.intersection(pluginNames, _.castArray(Plugin.disablePlugin(options))));
+      }
+      return result;
+    },
+    []
+  );
+
+  const enabledPlugins = await pluginNames.reduce(async (result, plugin) => {
+    if (plugin in plugins && !disabledPlugins.includes(plugin)) {
+      const Plugin = plugins[plugin];
+      const pluginOptions = context[plugin];
+      if (await Plugin.isEnabled(pluginOptions)) {
+        const instance = new Plugin({ namespace: plugin, options: context, container });
+        debug({ namespace: plugin, options: instance.options });
+        (await result).push(instance);
+      }
+    }
+    return result;
+  }, []);
+
+  return [enabledPlugins, enabledExternalPlugins];
+};