vulcan 0.0.1 → 0.0.2

data/server/node_modules/connect-form/support/connect/lib/connect/middleware/cache.js

@@ -0,0 +1,142 @@
+
+/*!
+ * Ext JS Connect
+ * Copyright(c) 2010 Sencha Inc.
+ * MIT Licensed
+ */
+
+/**
+ * Module dependencies.
+ */
+
+var Buffer = require('buffer').Buffer;
+
+/**
+ * Cache in memory for the given `cacheDuration`.
+ *
+ * @param {Number} cacheDuration
+ * @return {Function}
+ * @api public
+ */
+
+module.exports = function cache(cacheDuration){
+    var cache = {},
+        queue = {};
+
+    return function cache(req, res, next) {
+
+        // Skip all requests that are not GET method
+        if (req.method !== "GET") {
+            next();
+            return;
+        }
+
+        var key = req.headers["accept-encoding"] + req.url,
+            writeHead = res.writeHead,
+            write = res.write,
+            end = res.end,
+            code,
+            headers,
+            chunks = [],
+            totalSize = 0;
+
+        function serve() {
+            var resp = cache[key];
+            var headers = resp.headers;
+            headers["Date"] = (new Date).toUTCString();
+            headers["Content-Length"] = resp.body.length;
+
+            if (localQueue) {
+                // Send everyone in the wait queue the response.
+                for (var i = 0, l = localQueue.length; i < l; i++) {
+                    var localRes = localQueue[i];
+                    localRes.writeHead(resp.code, headers);
+                    localRes.end(resp.body);
+                }
+                // Kill the wait queue
+                delete queue[key];
+            } else {
+                res.writeHead(resp.code, headers);
+                res.end(resp.body);
+            }
+
+        }
+
+        // If there is a cache-hit, serve it right away!
+        if (cache[key]) {
+            serve();
+            return;
+        }
+
+        var localQueue = queue[key];
+        if (localQueue) {
+            localQueue[localQueue.length] = res;
+            return;
+        }
+        localQueue = queue[key] = [res];
+
+        // Defer the call to writeHead
+        res.writeHead = function (setCode, setHeaders) {
+            code = setCode;
+            headers = setHeaders;
+        };
+
+        // Buffer the response body as an array of Buffer objects
+        res.write = function (chunk, encoding) {
+            if (typeof chunk === 'string') {
+                var length;
+                if (!encoding || encoding === 'utf8') {
+                    length = Buffer.byteLength(chunk);
+                }
+                var buffer = new Buffer(length);
+                buffer.write(chunk, encoding);
+                chunks.push(buffer);
+            } else {
+                chunks.push(chunk);
+            }
+            totalSize += chunk.length;
+        };
+
+        res.end = function (chunk, encoding) {
+            if (chunk) {
+                res.write(chunk, encoding);
+            }
+
+            // Combine the buffer array into a single buffer
+            var body = new Buffer(totalSize);
+            var offset = 0;
+            chunks.forEach(function (chunk) {
+                chunk.copy(body, offset);
+                offset += chunk.length;
+            });
+
+            // Store the result in the cache
+            cache[key] = {
+                body: body,
+                code: code,
+                headers: headers
+            };
+
+            // Put the original methods back in place
+            res.writeHead = writeHead;
+            res.write = write;
+            res.end = end;
+
+            // Serve the response from the cache
+            serve();
+
+            if (cacheDuration) {
+                // Expire the ram cache after 100ms or the specified length
+                setTimeout(function(){
+                    delete cache[key];
+                }, cacheDuration);
+            } else {
+                // When the timeout is zero, just kill it right away
+                delete cache[key];
+            }
+
+        };
+
+        next();
+    };
+};

data/server/node_modules/connect-form/support/connect/lib/connect/middleware/cacheManifest.js

@@ -0,0 +1,71 @@
+
+/*!
+ * Ext JS Connect 0.0.1
+ * Copyright(c) 2010 Sencha Inc.
+ * MIT Licensed
+ */
+
+/**
+ * Module dependencies.
+ */
+
+var fs = require('fs'),
+    Utils = require('../utils'),
+    Url = require('url'),
+    Path = require('path');
+
+/**
+ * Generate cache manifest for the given `root`, `networks`,
+ * and `fallbacks`.
+ *
+ * @param {String} root
+ * @param {Array} networks
+ * @param {Array} fallbacks
+ * @return {Function}
+ * @api public
+ */
+
+module.exports = function cacheManifest(root, networks, fallbacks) {
+    root = root || process.cwd();
+    var suffix = "";
+
+    // List of networks as an array of strings
+    if (networks) {
+        suffix += "\n\nNETWORK:\n" + networks.join("\n");
+    }
+
+    // List of fallbacks as key/value pairs
+    if (fallbacks) {
+        suffix += "\n\nFALLBACK:\n" +
+            fallbacks.map(function (second, first) {
+                return first + " " + second;
+            }).join("\n");
+    }
+
+    return function cacheManifest(req, res, next) {
+        if (Url.parse(req.url).pathname === "/cache.manifest") {
+            Utils.find(root, (/./), function (err, files) {
+                var latestMtime = 0;
+                files = files.map(function (entry) {
+                    if (entry.mtime > latestMtime) {
+                        latestMtime = entry.mtime;
+                    }
+                    return entry.path.substr(1);
+                });
+                var manifest = "CACHE MANIFEST\n"
+                    + "# " + latestMtime.toUTCString() + "\n"
+                    + files.join("\n")
+                    + suffix;
+
+                res.writeHead(200, {
+                    "Content-Type": "text/cache-manifest",
+                    "Last-Modified": latestMtime.toUTCString(),
+                    "Content-Length": manifest.length
+                });
+                res.end(manifest);
+            });
+            return;
+        }
+        next();
+    };
+};

data/server/node_modules/connect-form/support/connect/lib/connect/middleware/compiler.js

@@ -0,0 +1,150 @@
+
+/*!
+ * Ext JS Connect
+ * Copyright(c) 2010 Sencha Inc.
+ * MIT Licensed
+ */
+
+/**
+ * Module dependencies.
+ */
+
+var fs = require('fs'),
+    path = require('path');
+
+/**
+ * Bundled compilers:
+ *
+ *  - [sass](http://github.com/visionmedia/sass.js) to _css_
+ *  - [less](http://github.com/cloudhead/less.js) to _css_
+ */
+
+var compilers = exports.compilers = {
+    sass: {
+        match: /\.css$/,
+        ext: '.sass',
+        compile: function(str, fn){
+            require.async('sass', function(err, sass){
+                if (err) {
+                    fn(err);
+                } else {
+                    try {
+                        fn(null, sass.render(str));
+                    } catch (err) {
+                        fn(err);
+                    }
+                }
+            });
+        }
+    },
+    less: {
+        match: /\.css$/,
+        ext: '.less',
+        compile: function(str, fn){
+            require.async('less', function(err, less){
+                if (err) {
+                    fn(err);
+                } else {
+                    try {
+                        less.render(str, fn);
+                    } catch (err) {
+                        fn(err);
+                    }
+                }
+            });
+        }
+    }
+};
+
+/**
+ * Setup compiler.
+ *
+ * Options:
+ *
+ *   - `src`     Source directory, defaults to **CWD**.
+ *   - `dest`    Destination directory, defaults `src`.
+ *   - `enable`  Array of enabled compilers.
+ *
+ * Compilers:
+ *
+ *   - `sass`   Compiles cass to css
+ *   - `less`   Compiles less to css
+ *
+ * @param {Object} options
+ * @api public
+ */
+
+module.exports = function compiler(options){
+    options = options || {};
+
+    var srcDir = process.connectEnv.compilerSrc || options.src || process.cwd(),
+        destDir = process.connectEnv.compilerDest || options.dest || srcDir,
+        enable = options.enable;
+
+    if (!enable || enable.length === 0) {
+        throw new Error('compiler\'s "enable" option is not set, nothing will be compiled.');
+    }
+
+    return function compiler(req, res, next){
+        for (var i = 0, len = enable.length; i < len; ++i) {
+            var name = enable[i],
+                compiler = compilers[name];
+            if (compiler.match.test(req.url)) {
+                var src = (srcDir + req.url).replace(compiler.match, compiler.ext),
+                    dest = destDir + req.url;
+
+                // Compare mtimes
+                fs.stat(src, function(err, srcStats){
+                    if (err) {
+                        if (err.errno === process.ENOENT) {
+                            res.writeHead(404, { 'Content-Type': 'text/plain' });
+                            res.end('Not Found');
+                        } else {
+                            next(err);
+                        }
+                    } else {
+                        fs.stat(dest, function(err, destStats){
+                            if (err) {
+                                // Oh snap! it does not exist, compile it
+                                if (err.errno === process.ENOENT) {
+                                    compile();
+                                } else {
+                                    next(err);
+                                }
+                            } else {
+                                // Source has changed, compile it
+                                if (srcStats.mtime > destStats.mtime) {
+                                    compile();
+                                } else {
+                                    // Defer file serving
+                                    next();
+                                }
+                            }
+                        })
+                    }
+                });
+
+                // Compile to the destination
+                function compile() {
+                    fs.readFile(src, 'utf8', function(err, str){
+                        if (err) {
+                            next(err);
+                        } else {
+                            compiler.compile(str, function(err, str){
+                                if (err) {
+                                    next(err);
+                                } else {
+                                    fs.writeFile(dest, str, 'utf8', function(err){
+                                        next(err);
+                                    });
+                                }
+                            });
+                        }
+                    });
+                }
+                return;
+            }
+        }
+        next();
+    };
+};

data/server/node_modules/connect-form/support/connect/lib/connect/middleware/conditionalGet.js

@@ -0,0 +1,71 @@
+
+/*!
+ * Ext JS Connect
+ * Copyright(c) 2010 Sencha Inc.
+ * MIT Licensed
+ */
+
+/**
+ * Conditional GET request support.
+ *
+ * @return {Function}
+ * @api public
+ */
+
+module.exports = function conditionalGet(){
+    return function conditionalGet(req, res, next) {
+        // Skip all requests that are not conditional gets.
+        if (!(req.method === "GET" &&
+             (req.headers["if-modified-since"] || req.headers["if-none-match"])
+           )) {
+            next();
+            return;
+        }
+
+        var since = req.headers["if-modified-since"],
+            oldEtag = req.headers["if-none-match"],
+            writeHead = res.writeHead,
+            write = res.write,
+            end = res.end;
+
+        since = since && Date.parse(since).valueOf();
+
+        res.writeHead = function (code, headers) {
+            var lastModified = headers["Last-Modified"],
+                etag = headers["Etag"];
+            lastModified = lastModified && Date.parse(lastModified).valueOf();
+
+            // If there is no match, then move on.
+            if (!(code === 200 &&
+                  (lastModified === since || oldEtag === etag)
+               )) {
+                res.writeHead = writeHead;
+                res.writeHead(code, headers);
+                return;
+            }
+
+            // Ignore writes
+            res.write = function () {};
+
+            res.end = function () {
+                // Put the original functions back on.
+                res.writeHead = writeHead;
+                res.write = write;
+                res.end = end;
+
+                // Filter out any Content based headers since there is no
+                // content.
+                var newHeaders = {};
+                headers.forEach(function (value, key) {
+                    if (key.indexOf("Content") < 0) {
+                        newHeaders[key] = value;
+                    }
+                });
+                res.writeHead(304, newHeaders);
+                res.end();
+            };
+        };
+
+        next();
+    };
+};

data/server/node_modules/connect-form/support/connect/lib/connect/middleware/cookieDecoder.js

@@ -0,0 +1,37 @@
+
+/*!
+ * Ext JS Connect
+ * Copyright(c) 2010 Sencha Inc.
+ * MIT Licensed
+ */
+
+/**
+ * Module dependencies.
+ */
+
+var utils = require('./../utils');
+
+/**
+ * Parse _Cookie_ header and populate `req.cookies`.
+ *
+ * @return {Function}
+ * @api public
+ */
+
+module.exports = function cookieDecoder(){
+    return function cookieDecoder(req, res, next) {
+        var cookie = req.headers.cookie;
+        req.cookies = {};
+        if (cookie) {
+            try {
+                req.cookies = utils.parseCookie(cookie);
+                delete req.headers.cookie;
+            } catch (err) {
+                // Ignore
+            }
+            next();
+        } else {
+            next();
+        }
+    };
+};