cli: add cwd, watch and ignore flags

Author: shakyShane

cli-options/opts.start.json

@@ -3,6 +3,10 @@
     "alias": "s",
     "desc": "Run a Local server (uses your cwd as the web root)"
   },
+  "cwd": {
+    "type": "string",
+    "desc": "Working directory"
+  },
   "serveStatic": {
     "type": "array",
     "alias": "ss",
@@ -26,6 +30,15 @@
     "alias": "b",
     "desc": "Choose which browser should be auto-opened"
   },
+  "watch": {
+    "type": "boolean",
+    "alias": "w",
+    "desc": "Watch files"
+  },
+  "ignore": {
+    "type": "array",
+    "desc": "Ignore patterns for file watchers"
+  },
   "files": {
     "type": "array",
     "alias": "f",

lib/bin.ts

@@ -55,10 +55,6 @@ function runFromCli() {
     const command = input[0];
     const valid = ["start", "init", "reload", "recipe"];
 
-    if (argv.help) {
-        return yargs.showHelp();
-    }
-
     if (valid.indexOf(command) > -1) {
         return handleIncoming(command, yargs.reset());
     }
@@ -169,11 +165,14 @@ function processStart(yargs) {
         .options(startOpts)
         .example("$0 start -s app", "- Use the App directory to serve files")
         .example("$0 start -p www.bbc.co.uk", "- Proxy an existing website")
+        .default('cwd', () => process.cwd())
         .help().argv;
 }
+
 /**
  * @param {string} command
  * @param {object} yargs
+ * @param cwd
  */
 function handleIncoming(command, yargs) {
     let out;
@@ -184,6 +183,7 @@ function handleIncoming(command, yargs) {
         out = yargs
             .usage("Usage: $0 init")
             .example("$0 init")
+            .default('cwd', () => process.cwd())
             .help().argv;
     }
     if (command === "reload") {
@@ -192,6 +192,7 @@ function handleIncoming(command, yargs) {
             .options(reloadOpts)
             .example("$0 reload")
             .example("$0 reload --port 4000")
+            .default('cwd', () => process.cwd())
             .help().argv;
     }
     if (command === "recipe") {
@@ -200,6 +201,7 @@ function handleIncoming(command, yargs) {
             .option(recipeOpts)
             .example("$0 recipe ls", "list the recipes")
             .example("$0 recipe gulp.sass", "use the gulp.sass recipe")
+            .default('cwd', () => process.cwd())
             .help().argv;
     }
 

lib/cli/cli-options.js

@@ -1,3 +1,5 @@
+import { List, Map } from "immutable";
+
 var path = require("path");
 var url = require("url");
 var _ = require("../lodash.custom");
@@ -274,12 +276,106 @@ opts.callbacks = {
  * @returns {Map}
  */
 opts.merge = function(values, argv) {
-    return immDefs.mergeDeep(values).withMutations(function(item) {
-        item.map(function(value, key) {
-            if (opts.callbacks[key]) {
-                item.set(key, opts.callbacks[key](value, argv));
+    const merged = immDefs.mergeDeep(values);
+    const transforms = [
+        function addToFilesOption(incoming) {
+            if (!incoming.get("watch")) {
+                return incoming;
             }
-        });
+
+            let serverPaths = [];
+
+            const fromServeStatic = incoming
+                .get("serveStatic", List([]))
+                .toArray();
+            const ssPaths = fromServeStatic
+                .reduce((acc, ss) => {
+                    if (typeof ss === "string") {
+                        return acc.concat(ss);
+                    }
+                    if (ss.dir && typeof ss.dir === "string") {
+                        return acc.concat(ss);
+                    }
+                    return acc;
+                }, [])
+                .map(p => path.resolve(p));
+
+            ssPaths.forEach(p => serverPaths.push(p));
+
+            const server = incoming.get("server");
+            if (server) {
+                if (server === true) {
+                    serverPaths.push(".");
+                }
+                if (typeof server === "string") {
+                    serverPaths.push(server);
+                }
+                if (
+                    List.isList(server) &&
+                    server.every(x => typeof x === "string")
+                ) {
+                    server.forEach(s => serverPaths.push(s));
+                }
+                if (Map.isMap(server)) {
+                    const baseDirs = server.get("baseDir", List([])).toArray();
+                    baseDirs.forEach(s => serverPaths.push(s));
+                }
+            }
+
+            const output = incoming.update("files", files => {
+                return List([])
+                    .concat(files, serverPaths)
+                    .filter(Boolean);
+            });
+            return output;
+        },
+        function addDefaultIgnorePatterns(incoming) {
+            if (!incoming.get("watch")) {
+                return incoming;
+            }
+
+            return incoming.update("watchOptions", watchOptions => {
+                const userIgnored = List([])
+                    .concat(watchOptions.get("ignored"))
+                    .filter(Boolean)
+                    .toSet();
+
+                const merged = userIgnored.merge([
+                    /node_modules/,
+                    /bower_components/,
+                    /\.sass-cache/,
+                    /\.vscode/,
+                    /\.git/,
+                    /\.idea/,
+                    "!node_modules/**/*",
+                    "!**/node_modules/**"
+                ]);
+
+                return watchOptions.merge({
+                    ignored: merged.toList(),
+                    cwd: incoming.get("cwd")
+                });
+            });
+        },
+        function copyCLIIgnoreToWatchOptions(incoming) {
+            if (!incoming.has("ignore")) {
+                return incoming;
+            }
+            return incoming.updateIn(["watchOptions", "ignored"], ignored => {
+                return ignored.merge(incoming.get("ignore"));
+            });
+        }
+    ];
+
+    const transformed = transforms.reduce((acc, item) => {
+        return item.call(null, acc);
+    }, merged);
+
+    return transformed.map(function(value, key) {
+        if (opts.callbacks[key]) {
+            return opts.callbacks[key](value, argv);
+        }
+        return value;
     });
 };
 

lib/cli/command.start.ts

@@ -15,11 +15,12 @@ const _ = require("../lodash.custom");
  */
 export default function(opts) {
     const flags = preprocessFlags(opts.cli.flags);
-    const maybepkg = path.resolve(process.cwd(), "package.json");
+    const cwd = flags.cwd || process.cwd();
+    const maybepkg = path.resolve(cwd, "package.json");
     let input = flags;
 
     if (flags.config) {
-        const maybeconf = path.resolve(process.cwd(), flags.config);
+        const maybeconf = path.resolve(cwd, flags.config);
         if (existsSync(maybeconf)) {
             const conf = require(maybeconf);
             input = _.merge({}, conf, flags);

lib/public/init.js

@@ -20,12 +20,12 @@ module.exports = function(browserSync, name, pjson) {
          * If the current instance is already running, just return an error
          */
         if (browserSync.active) {
-            return args.cb(
-                new Error("Instance: " + name + " is already running!")
-            );
+            return args.cb(new Error(`Instance: ${name} is already running!`));
         }
 
+        // Env specific items
         args.config.version = pjson.version;
+        args.config.cwd = args.config.cwd || process.cwd();
 
         return browserSync.init(merge(args.config), args.cb);
     };

lib/server/utils.js

@@ -112,7 +112,11 @@ var serverUtils = {
              * Note, this could throw, but let that happen as
              * the error message good enough.
              */
-            var maybe = path.resolve(process.cwd(), "node_modules", httpModule);
+            var maybe = path.resolve(
+                options.get("cwd"),
+                "node_modules",
+                httpModule
+            );
             return require(maybe);
         }