@epublishing/grunt-epublishing 0.3.0

package/.bumpedrc

@@ -0,0 +1,14 @@
+files:
+  - package.json
+  - package-lock.json
+plugins:
+ postrelease:
+   Committing new version:
+     plugin: bumped-terminal
+     command: 'git add package* && git commit -m "Version bump to v$newVersion"'
+   Publishing tag to Bitbucket:
+     plugin: bumped-terminal
+     command: 'git tag v$newVersion && git push && git push --tags'
+   Publishing to NPM:
+     plugin: bumped-terminal
+     command: npm publish .

package/.eslintrc

@@ -0,0 +1,6 @@
+{
+  "extends": [ "@epublishing/epublishing" ],
+  "rules": {
+    "strict": 0
+  }
+}

package/LICENSE

@@ -0,0 +1,18 @@
+Copyright 2017 ePublishing, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in the
+Software without restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the
+Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,113 @@
+# grunt-epublishing
+
+> Automated front-end tasks for ePublishing Jade and client sites.
+
+## Getting Started
+This plugin requires Grunt v1.0.0.
+
+If you haven't used [Grunt](http://gruntjs.com/) before, be sure to check out the [Getting Started](http://gruntjs.com/getting-started) guide, as it explains how to create a [Gruntfile](http://gruntjs.com/sample-gruntfile) as well as install and use Grunt plugins.
+
+NodeJS and Grunt-Cli must be installed before you proceed.
+
+If you are on Mac OS X and use homebrew. The following commands will get you ready to run grunt.
+
+
+```sh
+brew install node
+npm install -g grunt-cli
+```
+
+* To get started with using Grunt Jade you first need the right files within the project you wish to use this plugin. You will create a package.json and gruntfile.js in the root of your application. (unless someone has already done this)
+
+* The gruntfile should contain the following code which enables the default jade task:
+
+
+```js
+module.exports = function(grunt) {
+  // Load the grunt jade task
+  grunt.loadNpmTasks('@epublishing/grunt-epublishing');
+
+  // Run jade-default Grunt Task
+  grunt.registerTask('default', ['jade']);
+};
+```
+
+* The package.json file will contain the name of your site, version, and required dependencies that get installed before you can run "grunt". This file would look similar to this, and includes the actual required dependencies for Grunt Jade:
+
+
+```json
+{
+  "name": "jade-labs",
+  "version": "0.1.0",
+  "description":"jade-labs",
+  "repository": {
+    "type": "git",
+    "url": "git@bitbucket.org:epub_dev/jade"
+  },
+  "devDependencies": {
+    "grunt": "^1.0.0",
+    "grunt-jade": "git+ssh://git@bitbucket.org:epub_dev/grunt-jade.git"
+  }
+}
+```
+
+* Install the npm modules that this Grunt task depends on. To do this, run the following command in the application you wish to use this plugin.
+
+```sh
+npm install
+```
+
+Awesome! You are ready to run Grunt in the command line and watch Grunt Jade start working on your front-end assets. Grunt Jade will concatenate and minify the SCSS and Javascript. Here is what `grunt-jade` does when you run `grunt`:
+
+1. `set-jade-paths`: Resolve the locations of the active Jade gem, Jade child gem (if there is one), and site directories, making them available as config variables to subsequent tasks.
+1. `npm-install`: Install Node module dependencies in Jade and child gem locations if `package.json` files are present.
+1. `clean`: Clean (delete) previously compiled assets, if any.
+1. `babel`: Transpile standalone ES2015 scripts into public/javascripts/app with Babel.
+1. `concat`: Concatenate our default JS assets into a single script, `jade.default.js`.
+1. `uglify`: Minify the above script.
+1. `webpack`: Compile configured modules in `app/js` and bundle them with their dependencies using Webpack, saving them to `public/javascripts/app/bundle`.
+1. `sass`: Compile SCSS stylesheets to CSS using `libsass`.
+1. `bless`: _(disabled by default)_ Split compiled stylesheets into chunks in order to comply with MSIE 9's stylesheet selector limit.
+
+### Custom Tasks
+
+`grunt-jade` provides a couple of custom Grunt tasks that run as part of the default task set:
+
++ `set-jade-paths` makes Grunt's configuration aware of the ePublishing gems that a site depends on.
+  + Spawns a [Ruby script](./tasks/get-jade-gems.rb) as a subprocess that does the following things:
+    + Sets up Bundler and loads the site's RubyGems dependencies.
+    + Prints a list of gems whose names match the regular expression `/jade/` to stdout, as a JSON array.
+  + Parses the JSON array and populates `grunt.config.paths` with entries corresponding to:
+    + Jade's installation path as `paths.jade`
+    + The child gem's installation path (if any) as `paths.jadechild`
+    + Various relative asset directory paths (i.e. `paths.js_src`, `paths.css`, etc.)
++ `npm-install` iterates through the paths populated by `set-jade-paths` looking for package.json files.
+  + If any results are found, it does the following for each:
+    + Switches the current working directory to the parent folder of the current package.json result.
+    + Runs `npm install` as a subprocess and waits for it to complete.
+  + When all results have been processed, the task changes the working directory back to the site's root.
++ `watch-all` runs `grunt watch` and `grunt webpack --watch` at the same time in subprocesses
+
+## Release Management
+
+`grunt-epublishing` installs the [bumped](https://bumped.github.io/) package as a development dependency, and its package.json file provides an NPM script that can be used to increment release versions, commit, tag, push, and publish to NPM in a single step:
+
+```sh
+# Example (bump patch version):
+$ npm run release patch
+```
+
+## Local Development
+
+If you're working on new build system features, you can link your local clone of grunt-epublishing into a Jade site like
+so:
+
+```sh
+# Inside the grunt-epublishing directory:
+npm link
+
+# Change directories to the site:
+cd ../jade-site
+
+npm link @epublishing/grunt-epublishing
+```

package/__mocks__/@epublishing/get-gem-paths.js

@@ -0,0 +1,8 @@
+module.exports = function(_pattern, _workingDir) {
+  return Promise.resolve(
+    [
+      {path: '/path/to/jade', name: 'jade'},
+      {path: '/path/to/jade_child', name: 'jade_engine'},
+    ]
+  )
+}

package/etc/banner.txt

@@ -0,0 +1,6 @@
+┌─────────────────────────────┐
+│┳━┓┳━┓┳ ┓┳━┓┳  o┓━┓┳ ┳o┏┓┓┏━┓│
+│┣━ ┃━┛┃ ┃┃━┃┃  ┃┗━┓┃━┫┃┃┃┃┃ ┳│
+│┻━┛┇  ┇━┛┇━┛┇━┛┇━━┛┇ ┻┇┇┗┛┇━┛│
+└─────────────────────────────┘
+

package/etc/eslintrc.json

@@ -0,0 +1,49 @@
+{
+  "extends": [ "eslint:recommended", "plugin:react/recommended" ],
+  "parserOptions": {
+    "ecmaVersion": 6,
+    "sourceType": "module",
+    "ecmaFeatures": {
+      "impliedStrict": true,
+      "jsx": true,
+      "modules": true
+    }
+  },
+  "env": {
+    "browser": true,
+    "node": true,
+    "amd": true,
+    "es6": true,
+    "jquery": true
+  },
+  "settings": {
+    "react": {
+      "pragma": "React",
+      "version": "0.14.0"
+    }
+  },
+  "plugins": [
+    "react"
+  ],
+  "rules": {
+    "eqeqeq": [ 2, "smart" ],
+    "camelcase": 2,
+    "no-alert": 2,
+    "no-debugger": 2,
+    "no-console": 1,
+    "no-caller": 2,
+    "no-else-return": 1,
+    "no-eval": 2,
+    "no-extend-native": 1,
+    "no-useless-call": 1,
+    "no-case-declarations": 0,
+    "max-params": [ 2, 3 ],
+    "max-nested-callbacks": [ 2, 3 ],
+    "new-parens": 2,
+    "no-mixed-spaces-and-tabs": 2,
+    "operator-assignment": [ 2, "always" ],
+    "arrow-parens": [ 1, "always" ],
+    "react/no-danger": 1,
+    "react/prop-types": 1
+  }
+}

package/lib/base-config.js

@@ -0,0 +1,34 @@
+/* eslint-disable camelcase */
+/**
+ * This is the default, base configuration object into which grunt-jade merges
+ * additional configuration objects from Jade, engine gems, and the current site.
+ */
+
+'use strict';
+
+const path       = require('path');
+const modulesDir = path.resolve(require.resolve('lodash'), '..', '..');
+const Resolver   = require('@epublishing/jade-resolver');
+
+module.exports = {
+  Resolver,
+  paths: {
+    app: 'app',
+    css: 'public/stylesheets',
+    js: 'public/javascripts',
+    js_src: 'app/js',
+    scss: 'app/sass',
+    spec: 'spec/javascripts',
+  },
+  babel: {
+    options: {
+      sourceMap: false,
+      presets: [
+        [require.resolve('@epublishing/babel-preset-epublishing'), {
+          transformRuntime: false,
+          lodash: { cwd: modulesDir },
+        }],
+      ],
+    },
+  },
+};

package/lib/base-tsconfig.js

@@ -0,0 +1,14 @@
+module.exports = {
+  compilerOptions: {
+    allowJs: true,
+    experimentalDecorators: true,
+    allowSyntheticDefaultImports: true,
+    baseUrl: ".",
+    downlevelIteration: true,
+    forceConsistentCasingInFileNames: true,
+    lib: ["dom", "es6"],
+    module: "esnext",
+    moduleResolution: "node",
+    target: "es6",
+  },
+};

package/lib/cli-flags.js

@@ -0,0 +1,42 @@
+'use strict';
+
+const chalk = require('chalk');
+const cliui = require('cliui');
+
+const flags = {
+  debug: 'Pretty-print a representation of the complete Grunt config object',
+  lint: 'Check the syntax of Webpack bundle JS files w/ eslint',
+  'no-minify': 'Skip minification of Webpack bundles',
+  'no-banner': 'Suppress ASCII banner',
+  'no-time': 'Disable time-grunt performance stats',
+  analyze: 'Output Webpack bundle stats JSON and a graphical analysis of all bundles',
+  verbose: 'Show (much) more output',
+  watch: 'Keep Webpack alive and re-bundle when files change',
+  env: 'Sets process.env.NODE_ENV to the specified value',
+};
+
+const names = Object.keys(flags);
+
+module.exports = function cliFlags() {
+  const ui = cliui({ width: 100 });
+  ui.div({ text: chalk.cyan.bold('Option Flags:'), padding: [ 1, 0, 1, 0 ] });
+
+  for (const name of names) {
+    ui.div(
+      {
+        text: chalk.bold(`--${name}`),
+        width: 20,
+        padding: [ 0, 4, 0, 4 ],
+      },
+      {
+        text: flags[name],
+        width: 80,
+        padding: [ 0, 4, 0, 4 ],
+      }
+    );
+  }
+
+  return ui.toString();
+};
+
+module.exports.flags = flags;

package/lib/configure-postcss.js

@@ -0,0 +1,18 @@
+'use strict';
+
+const cssVariables = require('postcss-css-variables');
+
+module.exports = function configurePostCSS(config, grunt) {
+  config.postcss.options = {
+    map: {
+      inline: false,
+    },
+    processors: [
+      cssVariables({
+        preserve: true,
+      }),
+    ],
+  };
+
+  return config;
+};

package/lib/configure-sass.js

@@ -0,0 +1,24 @@
+/**
+ * This function merges custom SassScript functions into the base Sass config
+ */
+
+'use strict';
+
+const _        = require('lodash');
+const sass     = require('node-sass');
+const NODE_ENV = process.env.NODE_ENV || 'development';
+
+module.exports = function configureSass(config) {
+
+  config.sass.options.functions = {
+    'epub-show-deprecation-warnings()': () => {
+      if (_.includes([ 'local', 'development' ], NODE_ENV)) {
+        return sass.types.Boolean.TRUE;
+      }
+      return sass.types.Boolean.FALSE;
+    },
+    'epub-node-env()': () => new sass.types.String(NODE_ENV),
+  };
+
+  return config;
+};

package/lib/configure-webpack.js

@@ -0,0 +1,192 @@
+/**
+ * This function establishes base configuration for all detected Webpack build
+ * targets, including loaders and output plugins.
+ */
+
+'use strict';
+
+const os                   = require('os');
+const fs                   = require('fs');
+const path                 = require('path');
+const webpack              = require('webpack');
+const BundleAnalyzerPlugin = require('webpack-bundle-analyzer').BundleAnalyzerPlugin;
+const CompressionPlugin    = require('compression-webpack-plugin');
+const UglifyJsPlugin       = require('uglifyjs-webpack-plugin');
+const lodashDir            = path.dirname(require.resolve('lodash'));
+const moduleDir            = path.dirname(lodashDir);
+
+module.exports = function configureWebpack(grunt, config) {
+  const { NODE_ENV = 'development' } = process.env;
+  const watch    = !!grunt.option('watch');
+  const verbose  = !!grunt.option('verbose');
+  const noMinify = !!grunt.option('no-minify');
+  const analyze  = !!grunt.option('analyze');
+  const lint     = NODE_ENV === 'test' || !!grunt.option('lint');
+
+  for (const target in config.webpack) {
+    const targetConfig = config.webpack[target];
+
+    // This makes select environment variables from the shell running Grunt available
+    // in client-side JS files (with values hard-coded at compile-time). The property values
+    // in the EnvironmentPlugin's configuration object function as default values, which
+    // will be used if no variable corresponding to the property name can be found
+    // in the user's terminal environment.
+    //
+    // They are accessible from bundled scripts the same way that environment variables in Node.js
+    // scripts are - as properties of the `process.env` object (i.e. process.env.NODE_ENV).
+    const environmentVars = new webpack.EnvironmentPlugin({
+      NODE_ENV,
+      DEBUG: false,
+    });
+
+    // This prevents Webpack from loading every single locale definition file that Moment.js provides.
+    // 99% of the time we only care about formatting dates in US English, so we have no need for i.e.
+    // the preferred date formats of Esperanto-speaking residents of Papua New Guinea. American cultural hedgemony FTW!
+    const momentLocales = new webpack.ContextReplacementPlugin(/moment[/\\]locale$/, /en/);
+
+    let plugins = [ environmentVars, momentLocales ];
+
+    if (!config.babelLoader) {
+      config.babelLoader = { exceptions: [], exclude: /(node_modules|bower_components)/ };
+    }
+
+    const babelExclude = config.babelLoader.exclude;
+    const babelExceptions = config.babelLoader.exceptions.map((mod) => new RegExp(`node_modules/${mod}/(.+)\\.js$`));
+
+    targetConfig.watch                = watch;
+    targetConfig.keepalive            = watch || analyze;
+    targetConfig.stats.modules        = verbose;
+    targetConfig.stats.reasons        = verbose;
+    targetConfig.profile              = analyze;
+
+    // Tell babel-plugin-lodash where to find modularized Lo-Dash functions:
+    targetConfig.resolve.alias.lodash = lodashDir;
+
+    const babelOptions = {
+      presets: [
+        [require.resolve('@epublishing/babel-preset-epublishing'), {
+          lodash: { cwd: moduleDir },
+          env: {
+            modules: false,
+          },
+          minify: false,
+        }],
+      ],
+    }
+
+    const rules = [
+      {
+        test: /\.jsx?$/,
+        loader: 'babel-loader',
+        exclude: (input) => {
+          // Check whether the asset has a matching exclusion exception pattern and allow it to transpile if it does:
+          const isException = babelExceptions.some((pattern) => pattern.test(input));
+          if (isException) return !isException;
+
+          // Test asset against the default exclusion pattern and return result:
+          return babelExclude.test(input);
+        },
+        options: babelOptions,
+      },
+      {
+        test: /\.tsx?$/,
+        exclude: /node_modules/,
+        use: [
+          {
+            loader: 'babel-loader',
+            options: babelOptions,
+          },
+          {
+            loader: 'ts-loader',
+          },
+        ],
+      },
+      {
+        test: /\.css$/,
+        use: [
+          'style-loader',
+          'css-loader',
+        ],
+      },
+      {
+        test: [ /\.svg$/, /\.jpe?g$/, /\.gif$/, /\.png$/ ],
+        loader: 'file-loader',
+      },
+    ];
+
+    if (lint) {
+      const localEslintConfig = path.join(process.cwd(), '.eslintrc');
+      const globalEslintConfig = path.resolve(__dirname, '../.eslintrc');
+      const eslintConfig = fs.existsSync(localEslintConfig) ? localEslintConfig : globalEslintConfig;
+
+      rules.push({
+        enforce: 'pre',
+        test: /\.js$/,
+        exclude: /(node_modules|bower_components|public|vendor)/,
+        loader: 'eslint-loader',
+        options: {
+          configFile: eslintConfig,
+          formatter: require('eslint-friendly-formatter'),
+          failOnError: true,
+          outputReport: {
+            filePath: 'eslint.xml',
+            formatter: require('eslint/lib/formatters/junit'),
+          },
+        },
+      });
+    }
+
+    targetConfig.module = { rules };
+
+    if (analyze) {
+      const bundleAnalyzer = new BundleAnalyzerPlugin({
+        analyzerMode: 'server',
+        analyzerHost: '127.0.0.1',
+        analyzerPort: '8888',
+        reportFilename: 'webpack-analysis.html',
+        defaultSizes: 'parsed',
+        openAnalyzer: true,
+        generateStatsFile: true,
+        statsFilename: 'webpack.stats.json',
+        statsOptions: { chunkModules: true },
+      });
+      plugins.push(bundleAnalyzer);
+    }
+
+    if (!noMinify) {
+      const uglifyDefaults = {
+        cache: true,
+        sourceMap: true,
+        parallel: Math.max(os.cpus().length / 2, 1),
+      };
+      const { uglifyConfig = {} } = targetConfig;
+      delete targetConfig.uglifyConfig;
+
+      plugins.push(new UglifyJsPlugin(Object.assign({}, uglifyDefaults, uglifyConfig)));
+    }
+
+    if (NODE_ENV === 'production') {
+      plugins.push(new CompressionPlugin({
+        asset: '[path].gz',
+        algorithm: 'gzip',
+        test: /\.js$/,
+        threshold: 10240,
+        minRatio: 0.8,
+      }));
+    }
+
+    if (Array.isArray(targetConfig.appendPlugins)) {
+      plugins = plugins.concat(targetConfig.appendPlugins);
+      delete targetConfig.appendPlugins;
+    }
+
+    targetConfig.plugins = plugins;
+
+    if (targetConfig.customize && typeof targetConfig.customize === 'function') {
+      config.webpack[target] = targetConfig.customize(targetConfig, webpack);
+      delete config.webpack[target].customize;
+    }
+  }
+
+  return config;
+};

package/lib/gen-tsconfig.js

@@ -0,0 +1,64 @@
+const getGemPaths = require('@epublishing/get-gem-paths');
+const flatten = require('lodash/flatten');
+const merge = require('lodash/merge');
+const path = require('path');
+const baseConfig = require('./base-tsconfig');
+
+/**
+ * Generate an object representing all of the tsconfig.json files needed to build a site
+ * @param {string} sitePath - absolute path to site
+ * 
+ * @typedef {Object} TsconfigData
+ * @property {string} location - the absolute path of the tsconfig
+ * @property {Object} tsconfig - the tsconfig object to write to file
+ * 
+ * @returns TsconfigData[]
+ */
+module.exports = function genTsConfig(sitePath = process.cwd()) {
+  return getGemPaths('jade_?', sitePath)
+    .then(function(gems) {
+      const sourceRoots = gems
+        .concat() // don't mutate input param
+        .sort(function(a, _b) {
+          // jade should always come last
+          if (a.name === 'jade') return 1
+          return -1;
+        })
+        .map(function(gem) { return gem.path })
+
+      sourceRoots.unshift(sitePath) // site should always come first
+
+      const assetLocation = 'app/js/*' // only assets in app/js should be considered.
+
+      /** 
+       * for each source root get the relative path from the root to all roots 
+       * (including self) + each asset location
+      */
+      return sourceRoots.map((sourceRoot) => {
+
+        /**
+         * generate all of the relative paths between a given source 
+         * (site, jade engine or jade child) and all other sources
+        */
+        const relativePaths = sourceRoots.map((root) => {
+          const destination = path.resolve(root, assetLocation);
+          return path.relative(sourceRoot, destination);
+        })
+
+        const pathsField = {
+          compilerOptions: {
+            paths: {
+              '*': flatten(relativePaths),
+            },
+          },
+        }
+    
+        const tsconfig = merge({}, baseConfig, pathsField)
+    
+        return {
+          location: sourceRoot,
+          tsconfig,
+        }
+      })
+    })
+}

package/lib/init-jade-config.js

@@ -0,0 +1,91 @@
+/* eslint-disable max-params */
+/**
+ * Initializer function for creating a complete Grunt configuration object for
+ * an ePublishing Jade site. Merges config values from Jade, any detected engine
+ * gems, and the site itself.
+ */
+
+'use strict';
+
+const _                = require('lodash');
+const fs               = require('fs');
+const prettyjson       = require('prettyjson');
+const mergeConfigs     = require('./merge-configs');
+const configureWebpack = require('./configure-webpack');
+const configureSass    = require('./configure-sass');
+const configurePostCSS = require('./configure-postcss');
+
+module.exports = function initJadeConfig(grunt, jadePath, jadeChildPath, jadeChildPaths) {
+  // Initialize baseConfig
+  let baseConfig = require('./base-config');
+
+  baseConfig.paths.jade = jadePath;
+  baseConfig.paths.jadechild = jadeChildPath;
+
+  // Add in the jadeChildPaths
+  for (const i in jadeChildPaths) {
+    baseConfig.paths[i] = jadeChildPaths[i];
+  }
+
+  // Merge Jade's Grunt configuration into baseConfig
+  baseConfig = mergeConfigs(baseConfig, jadePath);
+
+  // Loop through all detected engine gem paths and merge their Grunt configurations into baseConfig
+  for (const childPath of _.values(jadeChildPaths)) {
+    baseConfig = mergeConfigs(baseConfig, childPath);
+  }
+
+  // Finally, merge the site's configuration values into baseConfig
+  baseConfig = mergeConfigs(baseConfig, process.cwd());
+
+  // Update baseConfig's Webpack settings with ePublishing defaults:
+  baseConfig = configureWebpack(grunt, baseConfig);
+
+  // Add custom functions and settings to the merged Sass config
+  baseConfig = configureSass(baseConfig);
+
+  if (baseConfig.postcss) {
+    baseConfig = configurePostCSS(baseConfig, grunt);
+  }
+
+  const jadeTasks = [
+    'gen-tsconfig',
+    'npm-install',
+    'clean',
+    'webpack',
+    'babel',
+    'concat',
+    'uglify',
+    'sass',
+    'clean-tsconfig',
+  ];
+
+  if (baseConfig.bless) {
+    jadeTasks.push('bless');
+  }
+
+  if (baseConfig.postcss) {
+    jadeTasks.push('postcss');
+  }
+
+  // Initialize the grunt configuration
+  grunt.config.init(baseConfig);
+
+  // Add package.json to the grunt config
+  grunt.config.set('pkg', grunt.file.readJSON('package.json'));
+
+  // Check to see if we need to add the bower tasks
+  if (fs.existsSync('bower.json')) {
+    jadeTasks.unshift('bower-install-simple', 'bower');
+  }
+
+  // Register the main jade task!
+  grunt.registerTask('jade', jadeTasks);
+
+  // This is left for legacy sake. The task should be called 'jade' because that's
+  // what this module is called, but some people are already using this.
+  grunt.registerTask('jade-default', jadeTasks);
+
+  // Optionally output the entire, merged config object via the --debug flag
+  grunt.log.debug(prettyjson.render(grunt.config.data));
+};

package/lib/merge-configs.js

@@ -0,0 +1,89 @@
+/* eslint-disable no-console */
+
+'use strict';
+
+const _    = require('lodash');
+const fs   = require('fs');
+const path = require('path');
+
+/**
+ * splits a path and returns the filename (everything after the last /)
+ * @param  {string} fullPath - A path to a file
+ * @returns {string} the extracted filename
+ */
+function getFilename(fullPath) {
+  if (!fullPath) {
+    console.trace();
+    throw new Error('fullPath was undefined');
+  }
+  return path.basename(fullPath);
+}
+
+ /**
+ * This function merges grunt configuration objects.
+ * This is a function fed into the lodash libraries
+ * _.merge function. It only handles merging arrays.
+ * The default is to just concat the dest array onto
+ * the end of the src array.
+ *
+ * However if the elements in the array contain references to .js files
+ * it instead checks the file name of the .js file (everything after the last /)
+ * and OVERRIDES the .js file from the source if it exists in the dest
+ *
+ * Any src js files that are not in the dest are simply added to the end of the dest
+ *
+ * @param   {Object} dest The destination object to be merged
+ * @param   {Object} src  The source object to be merged into the dest
+ * @returns {Object}      Either the dest object or undefined to let lodash handle it.
+ */
+function configMerger(dest, src) {
+  // We only trigger the custom merge for arrays
+  if (!_.isArray(dest)) return;
+
+  const jsRegExp = /[^*]\.js$/;
+
+  let i, j;
+
+  // JavaScript files with the same base name override one another:
+  for (i = 0; i < dest.length; i++) {
+    const destFile = getFilename(dest[i]);
+
+    if (!jsRegExp.test(destFile)) continue;
+
+    for (j = 0; j < src.length; j++) {
+      const srcFile = getFilename(src[j]);
+      if (destFile !== srcFile) continue;
+      dest[i] = src[j];
+    }
+  }
+
+  // All other array members are pushed and de-duped
+  for (const member of src) {
+    if (_.includes(dest, member)) continue;
+    dest.push(member);
+  }
+
+  return dest;
+}
+
+/**
+ * Merge a base Grunt configuration object with the configuration found
+ * in the specified base path, if any.
+ *
+ * @param {Object} baseConfig - The base Grunt configuration object
+ * @param {string} configDir - The root path of a site or Rails engine that contains additional configuration to be merged in
+ * @returns {Object} A new configuration object
+ */
+module.exports = function mergeConfigs(baseConfig, configDir) {
+  const configFile = path.join(configDir, 'config', 'grunt-config.js');
+
+  if (!fs.existsSync(configFile)) return baseConfig;
+
+  let config = require(configFile);
+
+  if (_.isFunction(config)) {
+    config = config(baseConfig);
+  }
+
+  return _.mergeWith({}, baseConfig, config, configMerger);
+};

package/lib/webpack-console-timer.js

@@ -0,0 +1,23 @@
+/* eslint-disable class-methods-use-this, no-console */
+
+const chalk = require('chalk');
+
+class WebpackConsoleTimer {
+  apply(compiler) {
+    compiler.plugin('compilation', (compilation) => {
+      let startOptimizePhase;
+
+      compilation.plugin('optimize-chunk-assets', (chunks, callback) => {
+        startOptimizePhase = Date.now();
+        callback();
+      });
+
+      compilation.plugin('after-optimize-chunk-assets', () => {
+        const optimizePhaseDuration = Date.now() - startOptimizePhase;
+        console.log(`\nOptimizer phase duration: ${chalk.bold(optimizePhaseDuration)}ms`);
+      });
+    });
+  }
+}
+
+module.exports = WebpackConsoleTimer;

package/package.json

@@ -0,0 +1,94 @@
+{
+  "name": "@epublishing/grunt-epublishing",
+  "description": "Automated front-end tasks for ePublishing Jade and client sites.",
+  "version": "0.3.0",
+  "homepage": "https://www.epublishing.com",
+  "contributors": [
+    {
+      "name": "Nick Brewer",
+      "email": "nbrewer@epublishing.com"
+    },
+    {
+      "name": "Mike Green",
+      "email": "mgreen@epublishing.com"
+    }
+  ],
+  "repository": "bitbucket:epub_dev/grunt-epublishing",
+  "license": "MIT",
+  "engines": {
+    "node": ">= 8.0.0"
+  },
+  "dependencies": {
+    "@epublishing/babel-preset-epublishing": "^0.1.6",
+    "@epublishing/get-gem-paths": "^0.1.1",
+    "@epublishing/grunt-install-eslint": "^0.1.1",
+    "@epublishing/jade-resolver": "^0.1.2",
+    "async": "^2.6.1",
+    "babel-loader": "^7.1.5",
+    "babel-minify-webpack-plugin": "^0.3.0",
+    "bourbon": "^4.2.7",
+    "breakpoint-sass": "^2.7.0",
+    "chalk": "^2.4.1",
+    "cli-spinner": "^0.2.8",
+    "cliui": "^4.1.0",
+    "compass-mixins": "^0.12.10",
+    "compression-webpack-plugin": "^1.1.7",
+    "css-loader": "^0.28.9",
+    "cssnano": "^4.0.5",
+    "es5-shim": "^4.5.10",
+    "es6-promise": "^4.2.4",
+    "eslint": "^5.3.0",
+    "eslint-friendly-formatter": "^4.0.1",
+    "eslint-loader": "^2.1.0",
+    "eslint-plugin-import": "^2.13.0",
+    "eslint-plugin-react": "^7.10.0",
+    "execa": "^0.10.0",
+    "exports-loader": "^0.7.0",
+    "expose-loader": "^0.7.4",
+    "file-loader": "^1.1.11",
+    "grunt": "^1.0.3",
+    "grunt-babel": "^7.0.0",
+    "grunt-bless": "^1.0.2",
+    "grunt-bower": "^0.21.4",
+    "grunt-bower-install-simple": "^1.2.6",
+    "grunt-contrib-clean": "^1.1.0",
+    "grunt-contrib-concat": "^1.0.1",
+    "grunt-contrib-uglify": "^3.4.0",
+    "grunt-contrib-watch": "^1.1.0",
+    "grunt-postcss": "^0.9.0",
+    "grunt-sass": "^2.1.0",
+    "grunt-webpack": "^3.1.2",
+    "handlebars": "^4.0.11",
+    "handlebars-loader": "^1.6.0",
+    "imports-loader": "^0.8.0",
+    "jit-grunt": "^0.10.0",
+    "listr": "^0.14.1",
+    "lodash": "^4.17.10",
+    "node-sass": "^4.14.1",
+    "postcss-css-variables": "^0.9.0",
+    "prettyjson": "^1.2.1",
+    "read-pkg": "^4.0.1",
+    "style-loader": "^0.20.2",
+    "susy": "^2.2.14",
+    "time-grunt": "^1.4.0",
+    "ts-loader": "^3.5.0",
+    "uglifyjs-webpack-plugin": "^1.2.7",
+    "webpack": "^3.12.0",
+    "webpack-bundle-analyzer": "^2.13.1",
+    "webpack-dev-server": "^2.11.1",
+    "worker-loader": "^2.0.0"
+  },
+  "keywords": [
+    "gruntplugin"
+  ],
+  "devDependencies": {
+    "@epublishing/eslint-config-epublishing": "^0.2.0",
+    "bumped": "^0.10.10",
+    "bumped-terminal": "^0.7.5",
+    "jest": "^24.9.0"
+  },
+  "scripts": {
+    "release": "bumped release",
+    "test": "jest"
+  }
+}

package/tasks/__tests__/gen-tsconfig.test.js

@@ -0,0 +1,74 @@
+const genTsConfig = require('../../lib/gen-tsconfig');
+
+function expectedConfig(sitePath) {
+
+  return [{
+    location: `${sitePath}`,
+    tsconfig: {
+      compilerOptions: {
+        allowSyntheticDefaultImports: true,
+        baseUrl: '.',
+        lib: ['dom', 'es6'],
+        module: 'esnext',
+        moduleResolution: 'node',
+        paths: {
+          '*': [
+            'app/js/*',
+            '../../path/to/jade_child/app/js/*',
+            '../../path/to/jade/app/js/*'
+          ]
+        },
+        target: 'es6'
+      }
+    }
+  }, {
+    location: '/path/to/jade_child',
+    tsconfig: {
+      compilerOptions: {
+        allowSyntheticDefaultImports: true,
+        baseUrl: '.',
+        lib: ['dom', 'es6'],
+        module: 'esnext',
+        moduleResolution: 'node',
+        paths: {
+          '*': [
+            `../../..${sitePath}/app/js/*`,
+            'app/js/*',
+            '../jade/app/js/*',
+          ]
+        },
+        'target': 'es6',
+      }
+    }
+  }, {
+    location: '/path/to/jade',
+    tsconfig: {
+      compilerOptions: {
+        allowSyntheticDefaultImports: true,
+        baseUrl: '.',
+        lib: ['dom', 'es6'],
+        module: 'esnext',
+        moduleResolution: 'node',
+        paths: {
+          '*': [
+            `../../..${sitePath}/app/js/*`,
+            '../jade_child/app/js/*',
+            'app/js/*'
+          ]
+        },
+        'target': 'es6',
+      }
+    }
+  }]
+}
+
+
+test('returns tsconfigs for pwd', function(done) {
+
+  const processSpy = jest.spyOn(process, 'cwd').mockImplementation(() => '/my/cwd');
+  genTsConfig().then(function(result) {
+      expect(result).toEqual(expectedConfig('/my/cwd'));
+      processSpy.mockClear()
+      done()
+    })
+})

package/tasks/clean-tsconfig.js

@@ -0,0 +1,37 @@
+/* eslint-disable no-console */
+'use strict';
+/**
+ * Remove tsconfig from site and jade engines
+ */
+module.exports = function (grunt) {
+  grunt.registerTask('clean-tsconfig', 'Remove tsconfig from site and jade engines', function() {
+    const genTsConfig = require('../lib/gen-tsconfig');
+    const fs   = require('fs')
+    const path = require('path')
+
+    const { NODE_ENV } = process.env;
+
+    /**
+     * if the build is not for a deployment (i.e. development), we'll want to keep tsconfigs
+     * a better developer experience
+    */
+    if ( NODE_ENV !== 'production' && NODE_ENV !== 'staging' ) {
+      console.log('Not deploying to production or stage. tsconfig.json will not be removed.');
+      return;
+    }
+
+    const done = this.async();
+    
+    genTsConfig(grunt.option('siteRoot'))
+      .then((configPayloads) => {
+        configPayloads.forEach(function(payload) {
+          const configPath = path.resolve(payload.location, 'tsconfig.json');
+          fs.unlinkSync(configPath)
+        })
+        done();
+      }).catch((err) => {
+        console.log(err)
+        done()
+      })
+  })
+}

package/tasks/gen-tsconfig.js

@@ -0,0 +1,38 @@
+/* eslint-disable no-console */
+'use strict';
+/**
+ * This task generates a tsconfig.json for the site as well as its jade engines.
+ */
+module.exports = function(grunt) {
+  grunt.registerTask('gen-tsconfig', 'Generate .tsconfig.json for site and all Jade engines', function() {
+    const genTsConfig = require('../lib/gen-tsconfig');
+    const path           = require('path');
+    const fs             = require('fs');
+
+    const done = this.async();
+    const tsConfigDotJson = 'tsconfig.json'
+
+    genTsConfig(grunt.option('siteRoot'))
+      .then((configPayloads) => {
+
+        configPayloads.forEach(function(payload) {
+          const configPath = path.resolve(payload.location, tsConfigDotJson);
+          createTSConfig(configPath, payload.tsconfig);
+        })
+
+        done();
+      })
+
+    /**
+     * creates a .tsconfig.json
+     * @param {string} path - path to write to
+     * @param {string} data - data to write
+     */
+    function createTSConfig(path, data) {
+      fs.writeFileSync(path, JSON.stringify(data))
+      console.log('created tsconfig.json for', path)
+    }
+  }
+  )
+}
+

package/tasks/jade.js

@@ -0,0 +1,72 @@
+/* eslint-disable no-console */
+
+'use strict';
+
+const path           = require('path');
+const timeGrunt      = require('time-grunt');
+const jitGrunt       = require('jit-grunt');
+const fs             = require('fs');
+const readPkg        = require('read-pkg');
+const getGemPaths    = require('@epublishing/get-gem-paths');
+const cliFlags       = require('../lib/cli-flags');
+const initJadeConfig = require('../lib/init-jade-config');
+
+module.exports = function(grunt) {
+  grunt.option('siteRoot', process.cwd())
+
+  if (!grunt.option('no-time')) timeGrunt(grunt);
+  jitGrunt(grunt, {
+    'install-eslint': '@epublishing/grunt-install-eslint',
+  });
+
+  /**
+   * This registers a grunt task which shells out and uses bundler to
+   * determine the paths to the jade gem and any jade child engine gem
+   */
+  grunt.registerTask('set-jade-paths', 'Get Jade Gem Paths', function() {
+    let jadePath;
+    let jadeChildPath;
+    const jadeChildPaths = {};
+    const isTerminal     = Boolean(process.stdout.isTTY);
+    const moduleRoot     = path.resolve(__dirname, '..');
+    const done           = this.async();
+    const asciiBanner    = fs.readFileSync(path.join(moduleRoot, 'etc/banner.txt'), 'utf8');
+    const modulePkg      = readPkg.sync({ cwd: moduleRoot });
+    const sitePkg        = readPkg.sync();
+    const banner = [
+      asciiBanner,
+      `grunt-epublishing v${modulePkg.version}`,
+      `currently building: ${sitePkg.name} v${sitePkg.version}`,
+      cliFlags(),
+    ].join('\n');
+
+    if (grunt.option('env')) {
+      process.env.NODE_ENV = grunt.option('env');
+    }
+
+    if (isTerminal && !grunt.option('no-banner')) grunt.log.writeln(`\n${banner}`);
+
+    // Query bundler for Jade-related gems in a subprocess
+    getGemPaths('jade_?')
+      .then((data) => {
+        for (const gem of data) {
+          if (gem.name === 'jade') {
+            jadePath = gem.path;
+          } else if ((/^jade_/).test(gem.name)) {
+            jadeChildPaths[gem.name] = gem.path;
+            jadeChildPath = gem.path;
+          }
+        }
+
+        done();
+        initJadeConfig(grunt, jadePath, jadeChildPath, jadeChildPaths);
+      })
+      .catch((err) => {
+        grunt.fail.fatal(err);
+        done();
+      });
+  });
+
+  // Force-run the `set-jade-paths` task
+  grunt.task.run(['set-jade-paths']);
+};

package/tasks/npm-install.js

@@ -0,0 +1,73 @@
+/**
+ * This registers a grunt task that performs an NPM install at each level of
+ * hierarchy that has a package.json file present (jade and child gem). Site
+ * level NPM installs are still manual.
+ */
+
+'use strict';
+
+module.exports = function(grunt) {
+  const _        = require('lodash');
+  const async    = require('async');
+  const path     = require('path');
+  const Resolver = require('@epublishing/jade-resolver');
+
+  grunt.registerTask('npm-install', 'Install Node module dependencies', function() {
+    const Spinner    = require('cli-spinner').Spinner;
+    const origPath   = process.cwd();
+    const resolver   = new Resolver(grunt.config.get('paths'));
+    const isTerminal = Boolean(process.stdout.isTTY);
+
+    resolver.removePath('site');
+
+    const packages = resolver.find('package.json');
+
+    if (_.isEmpty(packages)) {
+      grunt.log.ok('No other package.json files found in hierarchy. Skipping npm-install task.');
+      return;
+    }
+
+    const done = this.async();
+    const installQueue = _.map(packages, (pkg) => {
+      const basePath = path.dirname(pkg);
+      const basename = path.basename(basePath);
+
+      return (callback) => {
+        const spinner = new Spinner('%s installing...');
+
+        spinner.setSpinnerString(Spinner.spinners[18]);
+
+        grunt.log.writeln(`Installing NPM modules in ${basename}`);
+
+        if (isTerminal) spinner.start();
+
+        process.chdir(basePath);
+
+        grunt.util.spawn({
+          cmd: 'npm',
+          args: [ 'ci' ],
+        }, (err, result) => {
+          if (err) {
+            grunt.fail.warn(err);
+          } else {
+            if (isTerminal) spinner.stop(true);
+            grunt.verbose.writeln(result.stdout);
+            grunt.log.ok('Success!');
+          }
+
+          callback(err, result);
+        });
+      };
+    });
+
+    async.series(installQueue, (err, results) => {
+      if (err) {
+        return done(err);
+      }
+
+      grunt.log.ok('All NPM packages installed');
+      process.chdir(origPath);
+      done(results);
+    });
+  });
+};

package/tasks/watch-all.js

@@ -0,0 +1,49 @@
+/**
+ * This allows both the standard watch task and the Webpack watcher to
+ * run concurrently
+ */
+
+'use strict';
+
+module.exports = (grunt) => {
+  grunt.registerTask('watch-all', 'Watch with Sass and Webpack concurrently', function() {
+    const done = this.async();
+    const { spawn } = require('child_process');
+    const cwd = process.cwd();
+    const { env } = process;
+    const [ nodeBin, gruntBin, ...argv ] = process.argv;
+    const flags = '--no-banner --no-time';
+    const tasks = [
+      `watch ${flags}`,
+      `webpack --watch ${flags}`,
+    ];
+
+    grunt.log.ok('Spawning watcher tasks...');
+
+    const subprocesses = tasks.map((task) => {
+      const args = [ gruntBin, ...task.split(' ') ];
+      const subprocess = spawn(nodeBin, args, {
+        cwd,
+        env,
+        stdio: 'inherit',
+      });
+
+      subprocess.on('error', (err) => {
+        grunt.log.fatal(err);
+      });
+
+      return subprocess;
+    });
+
+    const cleanup = (exit = false) => {
+      grunt.log.ok('Killing subprocesses...');
+      for (const subprocess of subprocesses) {
+        subprocess.kill('SIGKILL');
+      }
+      if (exit) process.exit();
+    };
+
+    process.on('exit', cleanup);
+    process.on('SIGINT', () => cleanup(true));
+  });
+};