release-it 0.0.0-pl.0

package/lib/prompt.js

@@ -0,0 +1,33 @@
+import inquirer from 'inquirer';
+
+class Prompt {
+  constructor({ container }) {
+    this.createPrompt = (container.inquirer || inquirer).prompt;
+    this.prompts = {};
+  }
+
+  register(pluginPrompts, namespace = 'default') {
+    this.prompts[namespace] = this.prompts[namespace] || {};
+    Object.assign(this.prompts[namespace], pluginPrompts);
+  }
+
+  async show({ enabled = true, prompt: promptName, namespace = 'default', task, context }) {
+    if (!enabled) return false;
+
+    const prompt = this.prompts[namespace][promptName];
+    const options = Object.assign({}, prompt, {
+      name: promptName,
+      message: prompt.message(context),
+      choices: 'choices' in prompt && prompt.choices(context),
+      transformer: 'transformer' in prompt && prompt.transformer(context)
+    });
+
+    const answers = await this.createPrompt([options]);
+
+    const doExecute = prompt.type === 'confirm' ? answers[promptName] : true;
+
+    return doExecute && task ? await task(answers[promptName]) : false;
+  }
+}
+
+export default Prompt;

package/lib/shell.js

@@ -0,0 +1,91 @@
+import util from 'node:util';
+import sh from 'shelljs';
+import { execa } from 'execa';
+import { format } from './util.js';
+
+const debug = util.debug('release-it:shell');
+
+sh.config.silent = !debug.enabled;
+
+const noop = Promise.resolve();
+
+class Shell {
+  constructor({ container }) {
+    this.log = container.log;
+    this.config = container.config;
+    this.cache = new Map();
+  }
+
+  exec(command, options = {}, context = {}) {
+    if (!command || !command.length) return;
+    return typeof command === 'string'
+      ? this.execFormattedCommand(format(command, context), options)
+      : this.execFormattedCommand(command, options);
+  }
+
+  async execFormattedCommand(command, options = {}) {
+    const { isDryRun } = this.config;
+    const isWrite = options.write !== false;
+    const isExternal = options.external === true;
+    const cacheKey = typeof command === 'string' ? command : command.join(' ');
+    const isCached = !isExternal && this.cache.has(cacheKey);
+
+    if (isDryRun && isWrite) {
+      this.log.exec(command, { isDryRun });
+      return noop;
+    }
+
+    this.log.exec(command, { isExternal, isCached });
+
+    if (isCached) {
+      return this.cache.get(cacheKey);
+    }
+
+    const result =
+      typeof command === 'string'
+        ? this.execStringCommand(command, options, { isExternal })
+        : this.execWithArguments(command, options, { isExternal });
+
+    if (!isExternal && !this.cache.has(cacheKey)) {
+      this.cache.set(cacheKey, result);
+    }
+
+    return result;
+  }
+
+  execStringCommand(command, options, { isExternal }) {
+    return new Promise((resolve, reject) => {
+      const childProcess = sh.exec(command, { async: true }, (code, stdout, stderr) => {
+        stdout = stdout.toString().trimEnd();
+        debug({ command, options, code, stdout, stderr });
+        if (code === 0) {
+          resolve(stdout);
+        } else {
+          reject(new Error(stderr || stdout));
+        }
+      });
+      childProcess.stdout.on('data', stdout => this.log.verbose(stdout.toString().trimEnd(), { isExternal }));
+      childProcess.stderr.on('data', stderr => this.log.verbose(stderr.toString().trimEnd(), { isExternal }));
+    });
+  }
+
+  async execWithArguments(command, options, { isExternal }) {
+    const [program, ...programArgs] = command;
+
+    try {
+      const { stdout: out, stderr } = await execa(program, programArgs);
+      const stdout = out === '""' ? '' : out;
+      this.log.verbose(stdout, { isExternal });
+      debug({ command, options, stdout, stderr });
+      return Promise.resolve(stdout || stderr);
+    } catch (error) {
+      if (error.stdout) {
+        this.log.log(`\n${error.stdout}`);
+      }
+      debug({ error });
+      return Promise.reject(new Error(error.stderr || error.message));
+    }
+  }
+}
+
+export default Shell;

package/lib/spinner.js

@@ -0,0 +1,29 @@
+import { oraPromise } from 'ora';
+import { format } from './util.js';
+
+const noop = Promise.resolve();
+
+class Spinner {
+  constructor({ container = {} } = {}) {
+    this.config = container.config;
+    this.ora = container.ora || oraPromise;
+  }
+  show({ enabled = true, task, label, external = false, context }) {
+    if (!enabled) return noop;
+
+    const { config } = this;
+    this.isSpinnerDisabled = !config.isCI || config.isVerbose || config.isDryRun || config.isDebug;
+    this.canForce = !config.isCI && !config.isVerbose && !config.isDryRun && !config.isDebug;
+
+    const awaitTask = task();
+
+    if (!this.isSpinnerDisabled || (external && this.canForce)) {
+      const text = format(label, context);
+      this.ora(awaitTask, text);
+    }
+
+    return awaitTask;
+  }
+}
+
+export default Spinner;

package/lib/util.js

@@ -0,0 +1,109 @@
+import fs from 'node:fs';
+import { EOL } from 'node:os';
+import _ from 'lodash';
+import gitUrlParse from 'git-url-parse';
+import semver from 'semver';
+import osName from 'os-name';
+import Log from './log.js';
+
+const readJSON = file => JSON.parse(fs.readFileSync(file, 'utf8'));
+
+const pkg = readJSON(new URL('../package.json', import.meta.url));
+
+const log = new Log();
+
+const getSystemInfo = () => {
+  return {
+    'release-it': pkg.version,
+    node: process.version,
+    os: osName()
+  };
+};
+
+const format = (template = '', context = {}) => {
+  try {
+    return _.template(template)(context);
+  } catch (error) {
+    log.error(`Unable to render template with context:\n${template}\n${JSON.stringify(context)}`);
+    log.error(error);
+    throw error;
+  }
+};
+
+const truncateLines = (input, maxLines = 10, surplusText = null) => {
+  const lines = input.split(EOL);
+  const surplus = lines.length - maxLines;
+  const output = lines.slice(0, maxLines).join(EOL);
+  return surplus > 0 ? (surplusText ? `${output}${surplusText}` : `${output}${EOL}...and ${surplus} more`) : output;
+};
+
+const wait = ms => new Promise(resolve => setTimeout(resolve, ms));
+
+const rejectAfter = (ms, error) =>
+  wait(ms).then(() => {
+    throw error;
+  });
+
+const parseGitUrl = remoteUrl => {
+  if (!remoteUrl) return { host: null, owner: null, project: null, protocol: null, remote: null, repository: null };
+  const normalizedUrl = (remoteUrl || '')
+    .replace(/^[A-Z]:\\\\/, 'file://') // Assume file protocol for Windows drive letters
+    .replace(/^\//, 'file://') // Assume file protocol if only /path is given
+    .replace(/\\+/g, '/'); // Replace forward with backslashes
+  const parsedUrl = gitUrlParse(normalizedUrl);
+  const { resource: host, name: project, protocol, href: remote } = parsedUrl;
+  const owner = protocol === 'file' ? _.last(parsedUrl.owner.split('/')) : parsedUrl.owner; // Fix owner for file protocol
+  const repository = `${owner}/${project}`;
+  return { host, owner, project, protocol, remote, repository };
+};
+
+const reduceUntil = async (collection, fn) => {
+  let result;
+  for (const item of collection) {
+    if (result) break;
+    result = await fn(item);
+  }
+  return result;
+};
+
+const hasAccess = path => {
+  try {
+    fs.accessSync(path);
+    return true;
+  } catch (err) {
+    return false;
+  }
+};
+
+const parseVersion = raw => {
+  if (raw == null) return { version: raw, isPreRelease: false, preReleaseId: null };
+  const version = semver.valid(raw) ? raw : semver.coerce(raw);
+  if (!version) return { version: raw, isPreRelease: false, preReleaseId: null };
+  const parsed = semver.parse(version);
+  const isPreRelease = parsed.prerelease.length > 0;
+  const preReleaseId = isPreRelease && isNaN(parsed.prerelease[0]) ? parsed.prerelease[0] : null;
+  return {
+    version: version.toString(),
+    isPreRelease,
+    preReleaseId
+  };
+};
+
+const e = (message, docs, fail = true) => {
+  const error = new Error(docs ? `${message}${EOL}Documentation: ${docs}${EOL}` : message);
+  error.code = fail ? 1 : 0;
+  return error;
+};
+
+export {
+  getSystemInfo,
+  format,
+  truncateLines,
+  rejectAfter,
+  reduceUntil,
+  parseGitUrl,
+  hasAccess,
+  parseVersion,
+  readJSON,
+  e
+};

package/package.json

@@ -0,0 +1,122 @@
+{
+  "name": "release-it",
+  "version": "0.0.0-pl.0",
+  "description": "Generic CLI tool to automate versioning and package publishing-related tasks.",
+  "keywords": [
+    "build",
+    "changelog",
+    "commit",
+    "distribution",
+    "git",
+    "github",
+    "gitlab",
+    "interactive",
+    "ci",
+    "npm",
+    "publish",
+    "push",
+    "release",
+    "release-it",
+    "repository",
+    "script",
+    "shell",
+    "tag",
+    "tool",
+    "version",
+    "semver",
+    "plugin"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/release-it/release-it.git"
+  },
+  "homepage": "https://github.com/release-it/release-it#readme",
+  "bugs": "https://github.com/release-it/release-it/issues",
+  "bin": {
+    "release-it": "bin/release-it.js"
+  },
+  "type": "module",
+  "exports": {
+    ".": "./lib/index.js",
+    "./package.json": "./package.json",
+    "./test/util/index.js": "./test/util/index.js"
+  },
+  "files": [
+    "bin",
+    "config",
+    "lib",
+    "test"
+  ],
+  "scripts": {
+    "knip": "knip",
+    "lint": "eslint lib test",
+    "format": "prettier --write \"{lib,test}/**/*.js\"",
+    "docs": "remark README.md 'docs/**/*.md' '.github/*.md' -o",
+    "test": "ava --no-worker-threads",
+    "release": "./bin/release-it.js"
+  },
+  "author": {
+    "email": "lars@webpro.nl",
+    "name": "Lars Kappert"
+  },
+  "license": "MIT",
+  "dependencies": {
+    "@iarna/toml": "2.2.5",
+    "@octokit/rest": "19.0.13",
+    "async-retry": "1.3.3",
+    "chalk": "5.3.0",
+    "cosmiconfig": "8.3.6",
+    "execa": "7.2.0",
+    "git-url-parse": "13.1.0",
+    "globby": "13.2.2",
+    "got": "13.0.0",
+    "inquirer": "9.2.11",
+    "is-ci": "3.0.1",
+    "issue-parser": "6.0.0",
+    "lodash": "4.17.21",
+    "mime-types": "2.1.35",
+    "new-github-release-url": "2.0.0",
+    "node-fetch": "3.3.2",
+    "open": "9.1.0",
+    "ora": "7.0.1",
+    "os-name": "5.1.0",
+    "promise.allsettled": "1.0.7",
+    "proxy-agent": "6.3.1",
+    "semver": "7.5.4",
+    "shelljs": "0.8.5",
+    "update-notifier": "6.0.2",
+    "url-join": "5.0.0",
+    "wildcard-match": "5.1.2",
+    "yargs-parser": "21.1.1"
+  },
+  "devDependencies": {
+    "@octokit/request-error": "3.0.3",
+    "ava": "5.3.1",
+    "eslint": "8.50.0",
+    "eslint-config-prettier": "9.0.0",
+    "eslint-plugin-ava": "14.0.0",
+    "eslint-plugin-import": "2.28.1",
+    "eslint-plugin-prettier": "5.0.0",
+    "fs-monkey": "1.0.5",
+    "knip": "2.29.0",
+    "memfs": "4.5.0",
+    "mock-stdio": "1.0.3",
+    "nock": "13.3.3",
+    "prettier": "3.0.3",
+    "remark-cli": "11.0.0",
+    "remark-preset-webpro": "0.0.3",
+    "sinon": "16.0.0",
+    "strip-ansi": "7.1.0"
+  },
+  "overrides": {
+    "@octokit/plugin-rest-endpoint-methods": "7.2.2"
+  },
+  "engines": {
+    "node": ">=16"
+  },
+  "remarkConfig": {
+    "plugins": [
+      "preset-webpro"
+    ]
+  }
+}

package/test/cli.js

@@ -0,0 +1,20 @@
+import test from 'ava';
+import mockStdIo from 'mock-stdio';
+import { version, help } from '../lib/cli.js';
+import { readJSON } from '../lib/util.js';
+
+const pkg = readJSON(new URL('../package.json', import.meta.url));
+
+test('should print version', t => {
+  mockStdIo.start();
+  version();
+  const { stdout } = mockStdIo.end();
+  t.is(stdout, `v${pkg.version}\n`);
+});
+
+test('should print help', t => {
+  mockStdIo.start();
+  help();
+  const { stdout } = mockStdIo.end();
+  t.regex(stdout, RegExp(`Release It!.+${pkg.version}`));
+});

package/test/config.js

@@ -0,0 +1,144 @@
+import test from 'ava';
+import isCI from 'is-ci';
+import Config from '../lib/config.js';
+import { readJSON } from '../lib/util.js';
+
+const defaultConfig = readJSON(new URL('../config/release-it.json', import.meta.url));
+const projectConfig = readJSON(new URL('../.release-it.json', import.meta.url));
+
+const localConfig = { github: { release: true } };
+
+test("should read this project's own configuration", t => {
+  const config = new Config();
+  t.deepEqual(config.constructorConfig, {});
+  t.deepEqual(config.localConfig, projectConfig);
+  t.deepEqual(config.defaultConfig, defaultConfig);
+});
+
+test('should contain default values', t => {
+  const config = new Config({ configDir: './test/stub/config/default' });
+  t.deepEqual(config.constructorConfig, { configDir: './test/stub/config/default' });
+  t.deepEqual(config.localConfig, localConfig);
+  t.deepEqual(config.defaultConfig, defaultConfig);
+});
+
+test('should merge provided options', t => {
+  const config = new Config({
+    configDir: './test/stub/config/merge',
+    increment: '1.0.0',
+    verbose: true,
+    github: {
+      release: true
+    }
+  });
+  const { options } = config;
+  t.is(config.isVerbose, true);
+  t.is(config.isDryRun, false);
+  t.is(options.increment, '1.0.0');
+  t.is(options.git.push, false);
+  t.is(options.github.release, true);
+});
+
+test('should set CI mode', t => {
+  const config = new Config({ ci: true });
+  t.is(config.isCI, true);
+});
+
+test('should detect CI mode', t => {
+  const config = new Config();
+  t.is(config.options.ci, isCI);
+  t.is(config.isCI, isCI);
+});
+
+test('should override --no-npm.publish', t => {
+  const config = new Config({ npm: { publish: false } });
+  t.is(config.options.npm.publish, false);
+});
+
+test('should read YAML config', t => {
+  const config = new Config({ configDir: './test/stub/config/yaml' });
+  t.deepEqual(config.options.foo, { bar: 1 });
+});
+
+test('should read YML config', t => {
+  const config = new Config({ configDir: './test/stub/config/yml' });
+  t.deepEqual(config.options.foo, { bar: 1 });
+});
+
+test('should read TOML config', t => {
+  const config = new Config({ configDir: './test/stub/config/toml' });
+  t.deepEqual(config.options.foo, { bar: 1 });
+});
+
+test('should throw if provided config file is not found', t => {
+  t.throws(() => new Config({ config: 'nofile' }), { message: /no such file.+nofile/ });
+});
+
+test('should throw if provided config file is invalid (cosmiconfig exception)', t => {
+  t.throws(() => new Config({ config: './test/stub/config/invalid-config-txt' }), {
+    message: /Invalid configuration file at/
+  });
+});
+
+test('should throw if provided config file is invalid (no object)', t => {
+  t.throws(() => new Config({ config: './test/stub/config/invalid-config-rc' }), {
+    message: /Invalid configuration file at/
+  });
+});
+
+test('should not set default increment (for CI mode)', t => {
+  const config = new Config({ ci: true });
+  t.is(config.options.version.increment, undefined);
+});
+
+test('should not set default increment (for interactive mode)', t => {
+  const config = new Config({ ci: false });
+  t.is(config.options.version.increment, undefined);
+});
+
+test('should expand pre-release shortcut', t => {
+  const config = new Config({ increment: 'major', preRelease: 'beta' });
+  t.deepEqual(config.options.version, {
+    increment: 'major',
+    isPreRelease: true,
+    preReleaseId: 'beta'
+  });
+});
+
+test('should expand pre-release shortcut (preRelease boolean)', t => {
+  const config = new Config({ ci: true, preRelease: true });
+  t.deepEqual(config.options.version, {
+    increment: undefined,
+    isPreRelease: true,
+    preReleaseId: undefined
+  });
+});
+
+test('should expand pre-release shortcut (without increment)', t => {
+  const config = new Config({ ci: false, preRelease: 'alpha' });
+  t.deepEqual(config.options.version, {
+    increment: undefined,
+    isPreRelease: true,
+    preReleaseId: 'alpha'
+  });
+});
+
+test('should expand pre-release shortcut (including increment and npm.tag)', t => {
+  const config = new Config({ increment: 'minor', preRelease: 'rc' });
+  t.deepEqual(config.options.version, {
+    increment: 'minor',
+    isPreRelease: true,
+    preReleaseId: 'rc'
+  });
+});
+
+test('should expand pre-release shortcut (snapshot)', t => {
+  const config = new Config({ snapshot: 'feat' });
+  t.deepEqual(config.options.version, {
+    increment: 'prerelease',
+    isPreRelease: true,
+    preReleaseId: 'feat'
+  });
+  t.is(config.options.git.tagMatch, '0.0.0-feat.[0-9]*');
+  t.true(config.options.git.getLatestTagFromAllRefs);
+});