Merge branch 'better-ss'

Author: shakyShane

lib/async-tasks.js

@@ -45,10 +45,6 @@ module.exports = [
         step: "Starting the Server",
         fn: async.startServer
     },
-    {
-        step: "Adding serve static middlewares",
-        fn: async.addServeStaticMiddleware
-    },
     {
         step: "Starting the HTTPS Tunnel",
         fn: async.startTunnel

lib/async.js

@@ -246,18 +246,6 @@ module.exports = {
             }
         });
     },
-    /**
-     * @param bs
-     * @param done
-     */
-    addServeStaticMiddleware: function (bs, done) {
-        bs.options
-            .get("serveStatic")
-            .forEach(function (dir) {
-                bs.addMiddleware("*", utils.serveStatic(dir));
-            });
-        done();
-    },
     /**
      * @param {BrowserSync} bs
      * @param {Function} done

lib/browser-sync.js

@@ -655,7 +655,7 @@ BrowserSync.prototype.doFileReload = function (data) {
 
     /**
      * If the current item will cause the browser
-     * to reload, fire the correct 
+     * to reload, fire the correct
      */
     if (willReload) {
         bs.io.sockets.emit("browser:reload");

lib/server/utils.js

@@ -1,12 +1,16 @@
 "use strict";
 
-var fs        = require("fs");
-var filePath  = require("path");
-var connect   = require("connect");
-var http      = require("http");
-var https     = require("https");
-var Map       = require("immutable").Map;
-var snippet   = require("./../snippet").utils;
+var fs          = require("fs");
+var filePath    = require("path");
+var connect     = require("connect");
+var Immutable   = require("immutable");
+var http        = require("http");
+var https       = require("https");
+var Map         = require("immutable").Map;
+var snippet     = require("./../snippet").utils;
+var _           = require("./../../lodash.custom");
+var serveStatic = require("serve-static");
+var logger      = require("../logger");
 
 var utils = {
     /**
@@ -79,6 +83,25 @@ var utils = {
             })
         }
 
+        if (options.get("serveStatic")) {
+
+            var ssMiddlewares = utils.getServeStaticMiddlewares(options.get("serveStatic"), options.get("serveStaticOptions", Immutable.Map({})).toJS());
+            var withErrors    = ssMiddlewares.filter(function(x) { return x.errors.length > 0 });
+            var withoutErrors = ssMiddlewares.filter(function(x) { return x.errors.length === 0 });
+
+            if (withErrors.size) {
+                withErrors.forEach(function (item) {
+                    logger.logger.error("{red:Warning!} %s", item.errors[0].data.message);
+                });
+            }
+
+            if (withoutErrors.size) {
+                withoutErrors.forEach(function (item) {
+                    defaultMiddlewares.push.apply(defaultMiddlewares, item.items);
+                });
+            }
+        }
+
         /**
          * Add the proxy Middleware to the end of the stack
          */
@@ -146,6 +169,85 @@ var utils = {
             res.setHeader("Access-Control-Allow-Credentials", true);
             next();
         }
+    },
+    getServeStaticMiddlewares: function (ssOption, serveStaticOptions) {
+
+        return ssOption.map(function (dir, i) {
+
+            if (Immutable.Map.isMap(dir)) {
+
+                var ssOptions = (function () {
+                    if (dir.get("options")) {
+                        return dir.get("options").toJS();
+                    }
+                    return {}
+                })();
+
+                var route = dir.get("route");
+                var _dir  = dir.get("dir");
+
+                if (!isValidOption(route) || !isValidOption(_dir)) {
+                    return {
+                        items: [],
+                        errors: [{
+                            type: "Invalid Object",
+                            data: {
+                                message: "Serve Static requires both 'route' and 'dir' options when using an Object"
+                            }
+                        }]
+                    }
+                }
+                var ssItems = (function () {
+                    if (_.isString(route)) {
+                        return [{
+                            id: "Serve static " + i,
+                            route: getRoute(route),
+                            handle: serveStatic(_dir, ssOptions)
+                        }]
+                    }
+                    return route.map(function (item, j) {
+                        return {
+                            id: "Serve static " + i + "." + j,
+                            route: getRoute(item),
+                            handle: serveStatic(_dir, ssOptions)
+                        }
+                    }).toJS()
+                })();
+                return {
+                    items: ssItems,
+                    errors: []
+                };
+            }
+
+            if (_.isString(dir)) {
+                return {
+                    items: [
+                        {
+                            id: "Serve static " + i,
+                            route: "",
+                            handle: serveStatic(dir, serveStaticOptions)
+                        }
+                    ],
+                    errors: []
+                }
+            }
+
+            return {
+                items: [],
+                errors: [{
+                    type: "Invalid Type",
+                    data: {
+                        message: "Only strings and Objects (with route+dir) are supported for the ServeStatic option"
+                    }
+                }]
+            }
+        });
+        function isValidOption (x) {
+            return _.isString(x) || (_.isArray(x) && x.length > 0) || (Immutable.List.isList(x) && x.size > 0);
+        }
+        function getRoute (x) {
+            return x[0] === "/" ? x : "/" + x;
+        }
     }
 };