tunnckocore / hela3 Goto Github PK

// `prog` is `sade` instance
export async function commit({ prog, shell, argv }) {
  return prog
    .usage()
    .example()
    .option('--coverage, --cov', 'Run with coverage', true)
    .option('--check', 'Run with checking threshold coverage', true)
    .option('--build, -b', 'Run with build step', true)
    .action((opts) => shell('node test/index.js'));
}

import process from 'process';
import execa from 'execa-pro';
import sade from 'sade';

// the `dargs` from latest `gitcommit`
// externalize to `darks/darcks` - does opposite of `mri` parser
import dargs from './dargs'; // eslint-disable-line import/extensions, import/no-unresolved

const defaultOptions = {
  stdio: 'inherit',
  env: process.env,
};

/**
 * Executes improved version of [execa][] `.shell` method.
 *
 * @param {string|string[]} cmd
 * @param {object} [opts]
 * @public
 */
export function shell(cmd, opts) {
  const options = Object.assign({}, defaultOptions, opts);
  return execa.shell(cmd, options);
}

/**
 * Executes improved version of [execa][] `.exec` method.
 *
 * @param {string|string[]} cmd
 * @param {object} [opts]
 * @public
 */
export function exec(cmd, opts) {
  const options = Object.assign({}, defaultOptions, opts);
  return execa.exec(cmd, options);
}

/**
 *
 * @param {object} [options]
 * @public
 */
export function hela(options) {
  const prog = sade('hela').version('3.0.0');
  const opts = Object.assign(defaultOptions, options, { lazy: true });

  return Object.assign(prog, {
    /**
     * Define some function that will be called,
     * when no commands are given.
     * Allows bypassing the `No command specified.` error,
     * instead for example show the help output.
     * https://github.com/lukeed/sade/blob/987ffa974626e281de7ff0b9eaa63acadb2a134e/lib/index.js#L128-L130
     *
     * @param {Function} fn
     */
    commandless(fn) {
      const k = '__default__';
      const KEY = '__DEF__';
      prog.default = prog.curr = KEY; // eslint-disable-line no-multi-assign
      prog.tree[KEY] = Object.assign({}, prog.tree[k]);
      prog.tree[KEY].usage = '';
      prog.tree[KEY].handler = async () => fn();

      return prog;
    },

    /**
     * Action that will be done when command is called.
     *
     * @param {Function} fn
     * @public
     */
    action(fn) {
      const name = prog.curr || '__default__';
      const task = prog.tree[name];

      const stringActionWrapper = (cmd) => (...args) => {
        const argv = args[args.length - 1];
        const dargsOptions = Object.assign({ allowExtraFlags: true }, task);
        const flags = `${dargs(argv, dargsOptions).join(' ')}`;

        return shell(`${cmd} ${flags}`, opts);
      };

      if (typeof fn === 'function') {
        task.handler = async function fnc(...args) {
          const result = fn(...args);

          if (typeof result === 'string') {
            return stringActionWrapper(result)(...args);
          }

          // Specific & intentional case.
          // 1. Allows directly calling execa.shell
          // without passing the flags passed to hela task.
          // 2. Runs the commands in series.
          if (Array.isArray(result)) {
            return shell(result, opts);
          }

          return result;
        };
      }
      if (typeof fn === 'string') {
        task.handler = stringActionWrapper(fn);
      }
      if (Array.isArray(fn)) {
        fn.forEach((func) => {
          prog.action(func);
        });
      }

      // Friendlier error message.
      task.handler.command = () => {
        throw new Error('You cannot chain more after the `.action` call');
      };

      // Metadata about that specific task.
      task.handler.getMeta = () => task;
      return task.handler;
    },

    /**
     * Start the magic. Parse input commands and flags,
     * give them the corresponding command and its action function.
     *
     * @returns {Promise}
     * @public
     * @async
     */
    async listen() {
      const result = prog.parse(process.argv, opts);

      const { args, name, handler } = result;

      try {
        return handler(...args);
      } catch (err) {
        err.commandArgv = args[args.length - 1];
        err.commandArgs = args;
        err.commandName = name;
        throw err;
      }
    },
  });
}

/* eslint-disable import/extensions, import/no-unresolved */
import { hela } from './index';

const cli = hela();

/**
 * Hela's CLI options and commands
 */

cli.commandless(() => cli.help());

cli.option('--show-stack', 'Show error stack trace when command fail', false);

/**
 * TODO: loading of tasks/presets/config files
 *
 * @returns {Promise}
 */
async function main() {
  const configModule = await import('./echo-preset');
  const preset = Object.assign({}, configModule);

  if (preset.default && typeof preset.default === 'function') {
    const meta = preset.default.getMeta();
    const taskName = meta.usage.split(' ')[0];
    preset[taskName] = preset.default;
    delete preset.default;
  }

  const tasks = Object.keys(preset).reduce((acc, name) => {
    acc[name] = preset[name].getMeta();
    return acc;
  }, {});

  cli.tree = Object.assign({}, cli.tree, tasks);

  return cli.listen();
}

main()
  .then(() => {
    // This is a CLI file, so please.
    // eslint-disable-next-line unicorn/no-process-exit
    process.exit(0);
  })
  .catch((err) => {
    console.error('Error task:', err.commandName);

    if (err.commandArgv && !err.commandArgv['show-stack']) {
      console.error('Error message:', err.name, err.message);
    } else {
      console.error('Error stack:', err.stack);
    }

    // This is a CLI file, so please.
    // eslint-disable-next-line unicorn/no-process-exit
    process.exit(1);
  });

const { shell } = require('execa')

module.exports = ({ app }) => {
  shell("sed -i 's/src/dest/' test.js").catch(er => app.emit('error', er))
}

const { shell } = require('execa')

module.exports = ({ app }) => {
  shell("sed -i 's/dest/src/' test.js").catch(er => app.emit('error', er))
}