@eknkc/maket/src/bin.js

#!/usr/bin/env node

import program from "commander"
import cp from 'child_process'
import fs from 'fs'
import path from 'path'
import tsort from 'tsort'
import stream from 'stream'
import getconf from '@eknkc/maket-conf'
import flatten from './flatten'
import template from 'lodash.template'

const json = require.resolve('.bin/json');
const concurrently = require.resolve('.bin/concurrently');
const nodemon = require.resolve('.bin/nodemon');
const babel = require.resolve('.bin/babel');
const stylus = require.resolve('.bin/stylus');
const babelParams = ['-s', 'inline', '-D'];
const cwd = process.cwd();

const config = getconf(cwd);

if (!config)
  exit("No maket.yaml config found.");

function resolve(path, name = path) {
  try {
    let res = cp.spawnSync('/usr/bin/env', ['node', '-e', 'process.stdout.write(require.resolve(process.argv[1]))', path], { cwd })

    if (res.status !== 0)
      throw new Error();

    return res.stdout.toString('utf8');
  } catch(e) {
    return exit(`Unable to resolve ${name}`);
  }
}

program.command('browserify')
.option('-w, --watch', 'Watch mode')
.description("Build browserify bundle")
.action(function() {
  const browserify = require('browserify');
  const watchify = require('watchify');
  const browserifycss = require('browserify-css');
  const babelify = require('babelify');
  const envify = require('envify/custom');
  const factor = require('factor-bundle');

  if (!config.$browserify)
    return exit("No browserify configuration found.")

  let cnf = config.$browserify;

  if (!Array.isArray(cnf))
    cnf = [cnf];

  cnf.forEach(cf => {
    if (!cf.add || !cf.dest) return exit("Browserify needs an add and dest field");
    if (!Array.isArray(cf.add)) cf.add = [cf.add];
    cf.add = cf.add.map(a => path.resolve(cwd, a));

    var b = browserify(cf.add, {
      extensions: [".js", ".jsx", ".json", ".css"],
      paths: [path.join(cwd, 'node_modules')],
      cache: {},
      packageCache: {},
      debug: !!this.watch
    })
    .transform(babelify, { presets: [require('babel-preset-es2015'), require('babel-preset-react')] })
    .transform(browserifycss, {
      global: true,
      onFlush({ data }, done) {
        done(`
          (function() {
            var elem = document.createElement('style');
            var css = ${JSON.stringify(data)};
            elem.setAttribute('type', 'text/css');

            if ('textContent' in elem) {
              elem.textContent = css;
            } else {
              elem.styleSheet.cssText = css;
            }

            var head = document.getElementsByTagName('head')[0];
            head.appendChild(elem);
          })();
        `);
      }
    })
    .transform(envify({
      NODE_ENV: this.watch ? 'development' : 'production'
    }), {
      global: true
    })
    .transform((filename, opts) => {
      if (this.watch || /\.min\./.test(filename) || /\.json$/.test(filename))
        return new stream.PassThrough();

      var uglifyjs = require('uglify-js');

      var js = "";
      var transform = new stream.Transform();

      transform._transform = function(data, enc, next) {
        js += data.toString('utf8');
        next();
      }

      transform._flush = function(next) {
        try {
          js = uglifyjs.minify(js, { fromString: true }).code;
          this.push(js);
          next(null);
        } catch (e) {
          next(e);
        }
      }

      return transform;
    }, {
      global: true
    })

    if (cf.factor && Array.isArray(cf.factor))
      b.plugin(factor, { outputs: cf.factor.map(f => path.resolve(cwd, f)) });

    bundle();

    if (this.watch) {
      b.plugin(watchify);
      b.on('update', bundle);
    }

    function bundle() {
      b.bundle()
      .on('error', function(err) {
        console.log("browserify", "error")

        if (err._babel && err instanceof SyntaxError) {
          console.log(`${err.name}: ${err.message}\n${err.codeFrame}`);
        } else if (err.stack) {
          console.log(err.stack);
        } else {
          console.log(err);
        }
      })
      .pipe(fs.createWriteStream(path.resolve(cwd, cf.dest)))
      .on('close', () => {
        console.log('browserify', 'buildEnd', cf.dest)
      })
    }
  });
})

program.command('stylus')
.option('-w, --watch', 'Watch mode')
.description("Build stylus")
.action(function() {
  if (!config.$stylus)
    return exit("No stylus configuration found.")

  let entry = config.$stylus.entry;
  let dest = config.$stylus.dest;

  if (!entry || !dest)
    return exit("Malformed stylus config.")

  let params = ['-u', require.resolve('nib'), '-u', require.resolve('jeet'), '-u', require.resolve('rupture')];

  if (this.watch)
    params.push('-w', "--sourcemap-inline");
  else
    params.push('--compress')

  if (config.$stylus.paths) {
    config.$stylus.paths.forEach(p => params.push('-I', path.resolve(cwd, p)))
  }

  params.push('--out', path.resolve(cwd, dest))
  params.push(path.resolve(cwd, entry))

  console.log('stylus', this.watch ? 'watch' : 'buildStart', dest);
  cp.spawnSync(stylus, params, {
    stdio: ['ignore', 'ignore', 'inherit'],
    cwd: __dirname
  });
  console.log('stylus', 'buildEnd', dest);
})

program.command('babel')
.option('-w, --watch', 'Watch mode')
.description("Build babel")
.action(function() {
  if (!config.$babel)
    return exit("No babel configuration found.")

  let source = config.$babel.source;
  let dest = config.$babel.dest;

  if (!source || !dest)
    return exit("Babel requires source and dest.")

  let params = [...babelParams];

  params.push('--presets', [require.resolve('babel-preset-es2015-node'), require.resolve('babel-preset-stage-3')].join(','))

  if (this.watch)
    params.push('--watch');

  params.push('--out-dir', path.resolve(cwd, dest), path.resolve(cwd, source));

  console.log('babel', this.watch ? 'watch' : 'buildStart', source, dest);
  cp.spawnSync(babel, params, {
    stdio: ['ignore', 'ignore', 'inherit'],
    cwd: __dirname
  });
  console.log('babel', 'buildEnd', source, dest);
})

program.command('json [args...]')
.description("JSON helper")
.action(function(args) {
  cp.spawnSync(json, args, { stdio: 'inherit' });
})

program.command('concurrent [args...]')
.description("Run multiple shell commands at once")
.action(function(args) {
  cp.spawnSync(concurrently, ['-k', ...args], { stdio: 'inherit' });
})

program.command('nodemon -- [args...]')
.description("Nodemon proxy")
.action(function(args) {
  cp.spawnSync(nodemon, args, { stdio: 'inherit' });
})

program.command('run <script> [args...]')
.description("Run a maket script")
.action(function(script, args) {
  let scripts = {}
  let graph = tsort();

  addScript(script);

  function addScript(name) {
    if (scripts[name]) return;

    let scr = getScript(name);
    scripts[name] = scr;

    graph.add(name)

    if (scr.after.length) {
      scr.after.forEach(addScript)
      graph.add([...scr.after, name])
    }

    if (scr.before.length) {
      scr.before.forEach(addScript)
      graph.add([name, ...scr.before])
    }
  }

  let queue;

  try {
    queue = graph.sort().map(s => scripts[s])
  } catch(e) {
    return exit("There is a cycle in script order.");
  }

  let env = {
    MAKET: __filename
  };

  let fconf = flatten(config);

  Object.keys(fconf).forEach(k => {
    if (k.indexOf('$') >= 0)
      return;

    env[`MAKET_${k.toUpperCase().replace(/[\.\[\]]/g, '_')}`] = fconf[k]
  })

  let proc = cp.spawn('/usr/bin/env', ['bash'], {
    stdio: ['pipe', 'inherit', 'inherit'],
    env: Object.assign({}, process.env, env)
  });

  proc.stdin.write('set -e\n');

  queue.forEach(q => {
    q.commands.forEach(c => {
      proc.stdin.write(c + '\n')
    })
  })

  proc.stdin.end();
})

program.command('tpl <filename>')
.description("Render template")
.action(function(filename) {
  let tpl;

  try {
    tpl = fs.readFileSync(path.resolve(cwd, filename), { encoding: 'utf8' });
  } catch(e) {
    return exit("Unable to read file: " + filename);
  }

  process.stdout.write(template(tpl)(Object.assign({ encode }, config)));

  function encode(value) {
    return JSON.stringify(value).replace(/^"/, "").replace(/"$/, "");
  }
})

program.command('config [path]')
.description("Get maket configuration")
.action(function(cpath) {
  let res = config;

  if (cpath)
    res = res[cpath];

  if (typeof res === 'string')
    return process.stdout.write(res);

  process.stdout.write(JSON.stringify(res, null, "  "))
})

program.parse(process.argv)

function exit(message, code = -1) {
  console.error(message);
  process.exit(code);
}

function getScript(name) {
  let scripts = config.$scripts || {};
  let scr = scripts[name];

  if (!scr) return exit("Script not found.")

  if (typeof scr === 'string')
    scr = { commands: [scr] };
  else if (Array.isArray(scr))
    scr = { commands: scr };

  scr.after = scr.run_after || [];
  scr.before = scr.run_before || [];
  scr.commands = scr.commands || scr.cmd || [];

  if (!Array.isArray(scr.after)) scr.after = [scr.after];
  if (!Array.isArray(scr.before)) scr.before = [scr.before];
  if (!Array.isArray(scr.commands)) scr.commands = [scr.commands];

  return scr;
}