build-boiler/gulp/config/make-gulp-config.js

Build Boilerplate using Webpack, Eslint, Assemble, Nunjucks, and BrowserSync

'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };

exports.default = function (gulp) {
  var opts = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1];

  var babel = require('babel-core');
  var excludeRe = /^(.*?\/)?node_modules\/(?!@hfa\/).+\.jsx?$/;
  var include = opts.include;

  var parentDist = (0, _findParentDir.sync)(__dirname, 'dist');
  var parentMod = (0, _findParentDir.sync)(__dirname, 'node_modules');
  var rootDir = parentMod || parentDist || _path2.default.resolve(__dirname, '..', '..');

  var _makeCliConfig = (0, _makeCliConfig3.default)(rootDir);

  var cliConfig = _makeCliConfig.cliConfig;
  var plugins = _makeCliConfig.plugins;

  var hook = _requireHacker2.default.hook('js', function (hackedPath) {
    var shouldInclude = include ? include.test(hackedPath) : !excludeRe.test(hackedPath);
    var compiled = undefined;

    if (shouldInclude && hackedPath.indexOf(rootDir) === -1) {
      compiled = babel.transformFileSync(hackedPath, {
        sourceRoot: _path2.default.dirname(hackedPath)
      }).code;
    }

    return compiled;
  });
  var hasParentConfig = undefined,
      parentConfig = undefined;

  try {
    var fp = (0, _path.join)(process.cwd(), 'gulp', 'config', 'index.js');
    hasParentConfig = (0, _fs.statSync)(fp).isFile();

    parentConfig = require(fp);
    (0, _buildLogger2.default)('Merging parent ' + (0, _buildLogger.blue)('gulp/config') + ' with base config');
  } catch (err) {
    if (hasParentConfig) {
      throw err;
    }
  }

  var config = (0, _3.default)(cliConfig, rootDir, parentConfig);
  var sources = config.sources;
  var utils = config.utils;
  var taskDir = sources.taskDir;
  var addbase = utils.addbase;
  var addroot = utils.addroot;


  (0, _gulpTaskname2.default)(gulp);

  process.env.NODE_ENV = config.ENV;
  //hack for karma, ternary was making `undefined` a string
  if (config.file) {
    process.env.TEST_FILE = config.file;
  }

  /**
   * Reqires all gulp tasks passing the `gulp` object, all `plugins` and `config` object
   * Eliminates a lot of
   * @param {String} taskPath
   * @param {Function|Callback} supplied as `gulp.task`
   */
  function getTask(taskPath, moduleTask) {
    var fn = require(taskPath);
    var parentMod = undefined;

    if (moduleTask) {
      var foundPath = undefined;

      try {
        var normalizedPath = (0, _removeExtension2.default)(taskPath.replace(rootDir, ''));
        var parentPath = _path2.default.join(process.cwd(), 'gulp', 'tasks', normalizedPath);

        var filePath = parentPath + '.js';
        var dirPath = (0, _path.join)(parentPath, 'index.js');

        if ((0, _fs.existsSync)(filePath)) {
          foundPath = filePath;
        } else if ((0, _fs.existsSync)(dirPath)) {
          foundPath = dirPath;
        }

        if (foundPath) {
          parentMod = require(foundPath);
          (0, _buildLogger2.default)('Parent task found at ' + (0, _buildLogger.blue)((0, _renameKey2.default)(foundPath)));
        }
      } catch (err) {
        /**
         * If the file exists but couldn't be compiled then show the error
         */
        if (foundPath) {
          throw err;
        }
      }
    } else {
      (0, _buildLogger2.default)('Custom task found at ' + (0, _buildLogger.blue)((0, _renameKey2.default)(taskPath)));
    }

    return moduleTask ? fn(gulp, plugins, config, parentMod) : fn(gulp, plugins, config);
  }

  /**
   * Creates an object with keys corresponding to the Gulp task name and
   * values corresponding to the callback function passed as the second
   * argument to `gulp.task`
   * @param {String} basePath path to directory
   * @param {Array} dirs array of filepaths/direcotries
   * @param {Boolean} isModule flag of whether to look up at parent tasks
   * @return {Object} map of task names to callback functions to be used in `gulp.task`
   */
  function recurseTasks(basePath, dirs, isModule) {
    return dirs.reduce(function (acc, name) {
      var taskPath = (0, _path.join)(basePath, name);
      var isDir = (0, _fs.statSync)(taskPath).isDirectory();
      var taskName = undefined;
      if (isDir) {
        if (!(0, _fs.existsSync)((0, _path.join)(taskPath, 'index.js'))) {
          throw new Error('task ' + name + ' directory must have filename index.js');
        }
        taskName = name;
      } else {
        taskName = (0, _removeExtension2.default)(name);
      }

      return _extends({}, acc, _defineProperty({}, _lodash2.default.camelCase(taskName), getTask(taskPath, isModule)));
    }, {});
  }

  var tasksDir = addroot(taskDir, 'tasks');
  var internalDirs = (0, _fs.readdirSync)(tasksDir);
  var normalizedDirs = internalDirs.map(_removeExtension2.default);
  var moduleTasks = recurseTasks(tasksDir, internalDirs, true);
  var parentDir = addbase(taskDir, 'tasks');
  var parentTasks = {};

  try {
    var parentPaths = (0, _fs.readdirSync)(parentDir).filter(function (fp) {
      var base = fp.replace(_path2.default.extname(fp), '');

      return !normalizedDirs.includes(base);
    });

    parentTasks = recurseTasks(parentDir, parentPaths);
  } catch (err) {
    //eslint-disable-line no-empty:0
  }

  hook.unmount();

  var tasks = _extends({}, parentTasks, moduleTasks);

  return {
    tasks: tasks,
    config: config,
    plugins: plugins
  };
};

var _lodash = require('lodash');

var _lodash2 = _interopRequireDefault(_lodash);

var _fs = require('fs');

var _path = require('path');

var _path2 = _interopRequireDefault(_path);

var _findParentDir = require('find-parent-dir');

var _requireHacker = require('require-hacker');

var _requireHacker2 = _interopRequireDefault(_requireHacker);

var _2 = require('./');

var _3 = _interopRequireDefault(_2);

var _makeCliConfig2 = require('./make-cli-config');

var _makeCliConfig3 = _interopRequireDefault(_makeCliConfig2);

var _gulpTaskname = require('../utils/gulp-taskname');

var _gulpTaskname2 = _interopRequireDefault(_gulpTaskname);

var _renameKey = require('../utils/rename-key');

var _renameKey2 = _interopRequireDefault(_renameKey);

var _buildLogger = require('../utils/build-logger');

var _buildLogger2 = _interopRequireDefault(_buildLogger);

var _removeExtension = require('../utils/remove-extension');

var _removeExtension2 = _interopRequireDefault(_removeExtension);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }

module.exports = exports['default'];