wip against #706

Author: bmuenzenmeyer

core/lib/asset_copy.js

@@ -1,11 +1,111 @@
 "use strict";
 const plutils = require('./utilities');
-let fs = require('fs-extra'); // eslint-disable-line
+const _ = require('lodash');
+const path = require('path');
+const process = require('process');
 
-const asset_copy = () => {
-  const copyDirectory = (sourceDirectoryPath, destDirectoryPath) => {
-    return fs.copy(sourceDirectoryPath, destDirectoryPath);
+let copy = require('recursive-copy'); // eslint-disable-line
+let chokidar = require('chokidar'); // eslint-disable-line
+
+const asset_copier = () => {
+
+  const transform_paths = (directories) => {
+    //create array with all source keys minus our blacklist
+    const dirs = {};
+    const blackList = ['root', 'patterns', 'data', 'meta', 'annotations', 'styleguide', 'patternlabFiles'];
+    _.each(directories.source, (dir, key) => {
+
+      if (blackList.includes(key)) {
+        return;
+      }
+
+      if (!dirs.key) {
+        dirs[key] = {};
+      }
+    });
+
+    // loop through all source keys
+    _.each(dirs, (dir, key) => {
+      // add source key path
+      dirs[key].source = directories.source[key];
+
+      // add public key path
+      dirs[key].public = directories.public[key];
+    });
+    return dirs;
+  };
+
+  const copyFile = (p, dest, options) => {
+    copy(
+      p,
+      dest,
+      options
+    ).on(copy.events.COPY_FILE_COMPLETE, (copyOperation) => {
+      console.log(`Moved ${p} to ${dest}`);
+    });
+  };
+
+  const asset_copy = (assetDirectories, patternlab, options) => {
+    //take our configured paths and sanitize best we can to only the assets
+    const dirs = transform_paths(assetDirectories);
+
+    //find out where we are
+    const basePath = path.resolve(process.cwd());
+
+    const copyOptions =
+      {
+        overwrite: true
+      };
+
+      console.log(60, dirs)
+
+    //loop through each directory asset object (source / public pairing)
+    _.each(dirs, (dir, key) => {
+
+      //if we want to watch files, do so, otherwise just copy each file
+      if (options.watch) {
+        console.log(49, `watching ${path.resolve(basePath, dir.source)}`);
+        const watcher = chokidar.watch(
+          path.resolve(basePath, dir.source),
+          {
+            ignored: /(^|[\/\\])\../,
+            ignoreInitial: true,
+            awaitWriteFinish : {
+              stabilityThreshold: 1000,
+              pollInterval: 100
+            }
+          }
+        );
+
+        //watch for changes and copy
+        watcher.on('addDir', (p) => {
+          const destination = path.resolve(basePath, dir.public + '/' + path.basename(p));
+          copyFile(p, destination, copyOptions);
+        }).on('add', (p) => {
+          const destination = path.resolve(basePath, dir.public + '/' + path.basename(p));
+          copyFile(p, destination, copyOptions);
+        }).on('change', (p) => {
+          const destination = path.resolve(basePath, dir.public + '/' + path.basename(p));
+          copyFile(p, destination, copyOptions);
+        });
+
+      } else {
+        //just copy
+        const destination = path.resolve(basePath, dir.public);
+        copyFile(dir.source, destination, copyOptions);
+      }
+    });
   };
+
+  return {
+    copyAssets: (assetDirectories, patternlab, options) => {
+      asset_copy(assetDirectories, patternlab, options);
+    },
+    transformConfigPaths: (paths) => {
+      return transform_paths(paths);
+    }
+  };
+
 };
 
-module.exports = asset_copy;
+module.exports = asset_copier;

core/lib/patternlab.js

@@ -34,7 +34,7 @@ const CompileState = require('./object_factory').CompileState;
 let fs = require('fs-extra'); // eslint-disable-line
 let ui_builder = require('./ui_builder'); // eslint-disable-line
 let pattern_exporter = new pe(); // eslint-disable-line
-let assetCopy = require('./asset_copy');
+let assetCopier = require('./asset_copy'); // eslint-disable-line
 
 const pattern_assembler = new pa();
 const lineage_hunter = new lh();
@@ -654,14 +654,15 @@ const patternlab_engine = function (config) {
     v: function () {
       return getVersion();
     },
-    build: function (callback, deletePatternDir) {
+    build: function (callback, deletePatternDir, options) {
       if (patternlab && patternlab.isBusy) {
         console.log('Pattern Lab is busy building a previous run - returning early.');
         return Promise.resolve();
       }
       patternlab.isBusy = true;
       return buildPatterns(deletePatternDir).then(() => {
         new ui_builder().buildFrontend(patternlab);
+        assetCopier().copyAssets(patternlab.config.paths, patternlab, {watch: false});
         printDebug();
         patternlab.isBusy = false;
         callback();
@@ -693,11 +694,6 @@ const patternlab_engine = function (config) {
     },
     getSupportedTemplateExtensions: function () {
       return getSupportedTemplateExtensions();
-    },
-    copyAssets: function () {
-
-      // accept a filtered list of assets to copy. or use the default inferred from the config
-      assetCopy()
     }
   };
 };

package.json

@@ -5,18 +5,20 @@
   "main": "./core/lib/patternlab.js",
   "dependencies": {
     "async": "^2.1.2",
-    "dive": "^0.5.0",
     "chalk": "^1.1.3",
+    "chokidar": "^1.7.0",
+    "dive": "^0.5.0",
     "diveSync": "^0.3.0",
     "fs-extra": "^0.30.0",
     "fs-promise": "^1.0.0",
     "glob": "^7.0.0",
+    "graphlib": "^2.1.1",
     "js-beautify": "^1.6.3",
     "js-yaml": "^3.6.1",
     "lodash": "~4.13.1",
     "markdown-it": "^6.0.1",
     "node-fetch": "^1.6.0",
-    "graphlib": "^2.1.1"
+    "recursive-copy": "^2.0.6"
   },
   "devDependencies": {
     "eslint": "^3.5.0",
@@ -53,7 +55,7 @@
   "license": "MIT",
   "scripts": {
     "lint": "eslint core/**/*.js",
-    "pretest" : "npm run lint",
+    "pretest": "npm run lint",
     "test": "tap test/*_tests.js --reporter spec --coverage"
   },
   "engines": {

test/asset_copy_tests.js

@@ -0,0 +1,79 @@
+"use strict";
+
+var tap = require('tap');
+var rewire = require("rewire");
+var _ = require('lodash');
+var eol = require('os').EOL;
+var Pattern = require('../core/lib/object_factory').Pattern;
+var extend = require('util')._extend;
+var ac = rewire('../core/lib/asset_copy');
+var path = require('path');
+var config = require('./util/patternlab-config.json');
+
+var engineLoader = require('../core/lib/pattern_engines');
+engineLoader.loadAllEngines(config);
+
+//set up a global mocks - we don't want to be writing/rendering any files right now
+// var chokidarMock = {
+//   watch: function (path, data, cb) { }
+// };
+
+// ac.__set__({
+//   'chokidar': chokidarMock,
+// });
+
+const assetCopier = ac();
+
+function createFakePatternLab(customProps) {
+  var pl = {
+    config: {
+      paths: {
+        source: {
+          img: './test/img',
+          css: './test/css'
+        },
+        public: {
+          img: './test/output/img',
+          css: './test/output/css'
+        }
+      },
+      styleGuideExcludes: [ ],
+      debug: false,
+      outputFileSuffixes: {
+        rendered: '.rendered',
+        rawTemplate: '',
+        markupOnly: '.markup-only'
+      }
+    },
+    data: {}
+  };
+  return extend(pl, customProps);
+}
+
+// tap.test('transformConfigPaths takes configuration.paths() and maps to a better key store', function (test) {
+//   //arrange
+//   var patternlab = createFakePatternLab({});
+
+//   //act
+//   var result = assetCopy.transformConfigPaths(patternlab.config.paths);
+
+//   //assert
+//   test.equals(result.img.source, './test/img');
+//   test.equals(result.img.public, './test/output/img');
+//   test.equals(result.css.source, './test/css');
+//   test.equals(result.css.public, './test/output/css');
+//   test.end();
+// });
+
+tap.test('assetCopier does stuff', function(test) {
+  //arrange
+  var patternlab = createFakePatternLab({});
+
+  //act
+
+  assetCopier.copyAssets(patternlab.config.paths, {});
+
+  //assert
+
+  test.end();
+})