mako-config/index.js

'use strict'

let clone = require('clone')
let debug = require('debug')
let empty = require('is-empty')
let fs = require('mz/fs')
let glob = require('globby')
let merge = require('merge-array')
let path = require('path')
let Promise = require('bluebird')
let resolve = require('resolve').sync
let utils = require('mako-utils')

// single export
exports = module.exports = Promise.coroutine(load)
exports.sync = loadSync

/**
 * Loads a mako configuration file.
 *
 * @param {String} file        The absolute pathname to the config file to load.
 * @param {Array} [overrides]  User-supplied entries. (overrides config)
 * @return {Object}
 */
function * load (file, overrides) {
  debug('loading %s', utils.relative(file))
  let config = JSON.parse(yield fs.readFile(file, 'utf8'))
  let dir = path.dirname(file)
  let env = process.env.NODE_ENV || 'development'

  if (env in config) {
    debug('merging env %s', env)
    let envConf = config[env]
    if (envConf.entries) merge(config.entries, envConf.entries)
    if (envConf.plugins) merge(config.plugins, envConf.plugins)
  }

  let result = {
    entries: yield normalizeEntries(overrides, config.entries, dir),
    plugins: normalizePlugins(config.plugins, dir)
  }
  if (config.root) result.root = path.resolve(dir, config.root)
  if (config.concurrency) result.concurrency = config.concurrency
  debug('final config: %j', result)
  return result
}

/**
 * Synchronous version of load.
 *
 * @param {String} file        The absolute pathname to the config file to load.
 * @param {Array} [overrides]  User-supplied entries. (overrides config)
 * @return {Object}
 */
function loadSync (file, overrides) {
  debug('loading %s (sync)', utils.relative(file))
  let config = JSON.parse(fs.readFileSync(file, 'utf8'))
  let dir = path.dirname(file)
  let env = process.env.NODE_ENV || 'development'

  if (env in config) {
    debug('merging env %s', env)
    let envConf = config[env]
    if (envConf.entries) merge(config.entries, envConf.entries)
    if (envConf.plugins) merge(config.plugins, envConf.plugins)
  }

  let result = {
    entries: normalizeEntriesSync(overrides, config.entries, dir),
    plugins: normalizePlugins(config.plugins, dir)
  }
  if (config.root) result.root = path.resolve(dir, config.root)
  if (config.concurrency) result.concurrency = config.concurrency
  debug('final config: %j', result)
  return result
}

/**
 * Normalizes the list of entries. By default, the config file will contain a
 * complete list of entries. If the user passes a list of entries via the CLI,
 * that list will be used instead.
 *
 * It will return a flattened array of absolute file paths, with any globs
 * already expanded.
 *
 * @param {Array} input   The input list from the user. (if specified)
 * @param {Array} config  The list specified in the config file.
 * @param {String} dir    The location of the config file.
 * @return {Array}
 */
function normalizeEntries (input, config, dir) {
  let list = !empty(input) ? input : config
  return glob(list, { cwd: dir, realpath: true })
}

/**
 * Synchronous version of normalizeEntries.
 *
 * @param {Array} input   The input list from the user. (if specified)
 * @param {Array} config  The list specified in the config file.
 * @param {String} dir    The location of the config file.
 * @return {Array}
 */
function normalizeEntriesSync (input, config, dir) {
  let list = !empty(input) ? input : config
  return glob.sync(list, { cwd: dir, realpath: true })
}

/**
 * Normalizes the list of plugins. For each plugin specified in the config,
 * it will initialize. (with arguments if supplied) The return value is a flat
 * list of plugin functions.
 *
 * When a plugin is specified only as a string, it will be initialized without
 * arguments. (basically accepting the defaults)
 *
 * When a plugin is specified as an array, the first item is the plugin name,
 * all other items will be forwarded as arguments.
 *
 * @param {Array} config  The list of plugins specified in the config.
 * @param {String} root   The location of the config file.
 * @return {Array}
 */
function normalizePlugins (config, root) {
  if (!config) return []
  return config
    .map(plugin => {
      if (typeof plugin === 'string') return [ plugin ]
      return clone(plugin)
    })
    .map(plugin => {
      let fn = require(resolve(plugin[0], { basedir: root }))
      return fn.apply(null, plugin.slice(1))
    })
}