smart001 1.0.0

package/backend/node_modules/vary/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "vary",
+  "description": "Manipulate the HTTP Vary header",
+  "version": "1.1.2",
+  "author": "Douglas Christopher Wilson <doug@somethingdoug.com>",
+  "license": "MIT",
+  "keywords": [
+    "http",
+    "res",
+    "vary"
+  ],
+  "repository": "jshttp/vary",
+  "devDependencies": {
+    "beautify-benchmark": "0.2.4",
+    "benchmark": "2.1.4",
+    "eslint": "3.19.0",
+    "eslint-config-standard": "10.2.1",
+    "eslint-plugin-import": "2.7.0",
+    "eslint-plugin-markdown": "1.0.0-beta.6",
+    "eslint-plugin-node": "5.1.1",
+    "eslint-plugin-promise": "3.5.0",
+    "eslint-plugin-standard": "3.0.1",
+    "istanbul": "0.4.5",
+    "mocha": "2.5.3",
+    "supertest": "1.1.0"
+  },
+  "files": [
+    "HISTORY.md",
+    "LICENSE",
+    "README.md",
+    "index.js"
+  ],
+  "engines": {
+    "node": ">= 0.8"
+  },
+  "scripts": {
+    "bench": "node benchmark/index.js",
+    "lint": "eslint --plugin markdown --ext js,md .",
+    "test": "mocha --reporter spec --bail --check-leaks test/",
+    "test-cov": "istanbul cover node_modules/mocha/bin/_mocha -- --reporter dot --check-leaks test/",
+    "test-travis": "istanbul cover node_modules/mocha/bin/_mocha --report lcovonly -- --reporter spec --check-leaks test/"
+  }
+}

package/backend/node_modules/web/README.md

@@ -0,0 +1,191 @@
+# Web
+
+Web is a new node module designed for building web applications.  It's intended to replace the built-in `http` module as well as middle-ware systems like connect and stack.
+
+As the creator of the connect/stack interface, I've learned a lot over the years about what I could have done better.  Also the built-in `http` module in node itself has gotten bloated and complex since we've learned as we've gone on.  Features can be added a lot easier than they can be removed.  As a result, there are many different optional interfaces in the node HTTP interface.
+
+The new interface for web app layers found in `web` is closer modeled after the ideas in wsgi, rack, jsgi, strata.js and friends.  This allows for easy module composition and a simple but powerful interface through which layers can work together to build a complex web application.
+
+## The Old Interface
+
+In the old node interface as exposed by the `http` module, you create an HTTP server and pass it an HTTP request handler function.
+
+Usage looks like:
+
+```js
+// Old "http" handler interface built-in to node.js
+function handler(request, response) {
+  // request.method is "GET", "PUT", "POST", etc..
+  // request.url is "/foo/bar?and=stuff" ...
+  // and other interesting properties.
+  // Also request itself is a readable node stream
+  // representing the http request body.
+
+  // response.writeHead(code, headers)
+  // response.write(data)
+  // response.end(optionalData)
+  // and *many* other interfaces and alternate methods for setting
+  // headers and code.
+  // also the response object is a writable node stream representing
+  // the response body.
+}
+
+// Create a TCP server that parses HTTP protocol and
+// calls the handler function on each request.
+var server = http.createServer(handler);
+server.listen(8080);
+```
+
+This interface alone is not easy to wrap application layers and so middle-ware dispatchers like connect and stack were invented to ease the pain.  They still have several problems however.
+
+Considering it's history, this module has a pretty good API, but there is only so much you can do if you're learning as you go and are unable to break backwards compatibility.  Cruft will accumulate even under the watchful eye of the best maintainers.
+
+## The New Way
+
+The new interface is changed slightly.
+
+Firstly, instead of a `response` object that's both response stream and object full of random methods, there is a `respond` function that accepts status code, headers, and body.
+
+Second, it's not bound to the `net` module anymore.  I believe that parsing HTTP and listening on a real network socket should be two different responsibilities.  If you separate the two, then it's much easier to create mock servers that listen on fake sockets or exotic real servers that aren't TCP based.
+
+```js
+var app = function (request, respond) {
+  // request.method is "GET", "POST", "PUT", etc..
+  // request.url is the raw request path "/foo/bar?and=stuff"
+  // request.headers is the raw array of request headers.
+  // request.body is the request body as a stream.
+
+  // respond(code, headers, body) is a function
+  // body can be a string or a writable stream.
+}
+
+// This handler function expects a raw TCP connection
+// It handles HTTP parsing internally
+var handler = require('web').socketHandler(app);
+
+// To serve the HTTP app over TCP, we only need to connect to a TCP server.
+var server = require('net').createServer(handler);
+server.listen(8080);
+```
+
+## Built-in Middleware System
+
+Unlike the `http` module, `web` makes it trivial to stack app layers.  There is no need for a library because all that's needed is a simple function.  Any function that implements the `(request, respond)` interface is a valid web application.
+
+### Basic Logger Layer
+
+Suppose you wanted to add a layer that logged all request and the response code the app gave them.
+
+This can be done simple as:
+
+```js
+function logger(app) {
+  // Any per-layer startup logic would go here.
+  // We only need the app closure reference, so there is nothing else to do
+
+  return function(req, res) {
+
+    // Per request logic during the inward path would go here.  Since
+    // we want to wait till the response code is generated, there is nothing
+    // to do.
+
+    // Forward to the next layer inward.
+    app(req, function (code, headers, body) {
+
+      // Here we've intercepted the response function and can do stuff on the
+      // way back out of the layers.  We want to log the request and response.
+
+      console.log(req.method + " " + req.url.path + " " + code);
+
+      // Forward to the layers outward.
+      res(code, headers, body);
+    });
+  };
+}
+
+// Then to use this layer, we just wrap out app.
+app = logger(app);
+```
+
+As you can see, there are places to do logic at several steps in a request and server lifetime.
+
+
+## Request Object
+
+The request object contains the following properties.
+
+### req.method
+
+This is the HTTP method in the request.  It can have values like "GET", "POST", "PUT", "DELETE", and any other value the node http parser supports.
+
+
+### req.headers
+
+This is a hash of the headers with keys lowercases for easy access.
+
+It can be used as:
+
+```js
+if (req.headers["content-type"] === "application/json") { ... }
+```
+
+### req.url
+
+This is the result of node's url.parse on the http request url.
+`req.url.path` contains the original raw string if desired.
+`req.url.pathname` is the path alone without query strings.
+
+### req.versionMajor, req.versionMinor
+
+These two properties tell you the version of the http request.  They are usually either (1, 0) or (1, 1) for HTTP 1.0 and HTTP 1.1.
+
+### req.shouldKeepAlive
+
+This is a hint set by node's http parser to tell the middleware if it should
+keepalive the connection.
+
+### req.upgrade
+
+This is another hint set by node's http parser.  It's true for upgrade request like websocket connections.
+
+
+### req.body
+
+This property is set by the web library.  It's a readable node stream for the request body.
+
+### req.rawHeaders
+
+This is a raw array of alternating key/value pairs.  For example, the headers from a curl request look like:
+
+```js
+req.rawHeaders = [
+  'User-Agent', 'curl/7.26.0',
+  'Host',       'localhost:8080',
+  'Accept',     '*/*' ]
+```
+
+## Post response processing.
+
+The built-in response function does a bit of post-processing after your app is
+done to help your app be a proper http server.  These post-processing filters can be configured in the socketHandler function's options argument.
+
+### options.autoDate = true
+
+This options adds a `Date` header with the current date as required by the HTTP spec if your response does not have a `Date` header.
+
+### options.autoServer = "node.js " + process.version
+
+Adds a `Server` header with the running version of node if you don't have a `Server` header.  Set to some falsy value to disable or set to a new string to replace.
+
+### options.autoContentLength = true
+
+If your body is a known size (not streaming) and you leave out the `Content-Length` header, this will add one for you.
+
+### options.autoChunked = true
+
+If you leave out a `Content-Length` header and your body is streaming, it will replace your stream with a chunked encoded stream and set the proper `Transfer-Encoding: chunked` header for you.
+
+### options.autoConnection = true
+
+This will try to detect what the `Connection` header should be.  Usually either `close` or `keep-alive`.  Also it will update `req.shouldKeepAlive` which controls the tcp level connection behavior.
+

package/backend/node_modules/web/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "web",
+  "version": "0.0.2",
+  "description": "A small and fast web/http library for nodejs. (replaces the built-in http module)",
+  "main": "web.js",
+  "dependencies": {},
+  "devDependencies": {},
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/creationix/node-web.git"
+  },
+  "author": "Tim Caswell",
+  "license": "MIT"
+}

package/backend/node_modules/web/test-web.js

@@ -0,0 +1,16 @@
+
+function app(req, res) {
+  if (req.method === "GET" && req.url.path === "/") {
+    res(200, { "Content-Type": "text/plain" }, "Hello World\n");
+  }
+  else {
+    res(404, {}, "");
+  }
+}
+
+
+var server = require('net').createServer(require('./web').socketHandler(app));
+server.listen(8080, function () {
+  var address = server.address();
+  console.log("http://%s:%s/", address.address, address.port);
+});

package/backend/node_modules/web/web.js

@@ -0,0 +1,200 @@
+var HTTPParser = process.binding("http_parser").HTTPParser;
+var Stream = require('stream').Stream;
+var urlParse = require('url').parse;
+
+var STATUS_CODES = {
+  '100': 'Continue',
+  '101': 'Switching Protocols',
+  '102': 'Processing',                 // RFC 2518, obsoleted by RFC 4918
+  '200': 'OK',
+  '201': 'Created',
+  '202': 'Accepted',
+  '203': 'Non-Authoritative Information',
+  '204': 'No Content',
+  '205': 'Reset Content',
+  '206': 'Partial Content',
+  '207': 'Multi-Status',               // RFC 4918
+  '300': 'Multiple Choices',
+  '301': 'Moved Permanently',
+  '302': 'Moved Temporarily',
+  '303': 'See Other',
+  '304': 'Not Modified',
+  '305': 'Use Proxy',
+  '307': 'Temporary Redirect',
+  '400': 'Bad Request',
+  '401': 'Unauthorized',
+  '402': 'Payment Required',
+  '403': 'Forbidden',
+  '404': 'Not Found',
+  '405': 'Method Not Allowed',
+  '406': 'Not Acceptable',
+  '407': 'Proxy Authentication Required',
+  '408': 'Request Time-out',
+  '409': 'Conflict',
+  '410': 'Gone',
+  '411': 'Length Required',
+  '412': 'Precondition Failed',
+  '413': 'Request Entity Too Large',
+  '414': 'Request-URI Too Large',
+  '415': 'Unsupported Media Type',
+  '416': 'Requested Range Not Satisfiable',
+  '417': 'Expectation Failed',
+  '418': 'I\'m a teapot',              // RFC 2324
+  '422': 'Unprocessable Entity',       // RFC 4918
+  '423': 'Locked',                     // RFC 4918
+  '424': 'Failed Dependency',          // RFC 4918
+  '425': 'Unordered Collection',       // RFC 4918
+  '426': 'Upgrade Required',           // RFC 2817
+  '500': 'Internal Server Error',
+  '501': 'Not Implemented',
+  '502': 'Bad Gateway',
+  '503': 'Service Unavailable',
+  '504': 'Gateway Time-out',
+  '505': 'HTTP Version not supported',
+  '506': 'Variant Also Negotiates',    // RFC 2295
+  '507': 'Insufficient Storage',       // RFC 4918
+  '509': 'Bandwidth Limit Exceeded',
+  '510': 'Not Extended'                // RFC 2774
+};
+
+var defaults = {
+  autoDate: true,
+  autoServer: "node.js " + process.version,
+  autoContentLength: true,
+  autoChunked: true,
+  autoConnection: true,
+};
+exports.socketHandler = function (app, options) {
+  // Mix the options with the default config.
+  var config = Object.create(defaults);
+  for (var key in options) {
+    config[key] = options[key];
+  }
+
+  return function (client) {
+    var parser = new HTTPParser(HTTPParser.REQUEST);
+    var req;
+
+    function res(statusCode, headers, body) {
+
+      var hasContentLength, hasTransferEncoding, hasDate, hasServer;
+      for (var key in headers) {
+        switch (key.toLowerCase()) {
+          case "date": hasDate = true; continue;
+          case "server": hasServer = true; continue;
+          case "content-length": hasContentLength = true; continue;
+          case "transfer-encoding": hasTransferEncoding = true; continue;
+        }
+      }
+      if (!hasDate && config.autoDate) {
+        headers["Date"] = (new Date).toUTCString();
+      }
+      if (!hasServer && config.autoServer) {
+        headers["Server"] = config.autoServer;
+      }
+      var isStreaming = body && typeof body === "object" && typeof body.pipe === "function";
+      if (body && !hasContentLength && !hasTransferEncoding) {
+        if (!isStreaming && config.autoContentLength) {
+          body += "";
+          headers["Content-Length"] = Buffer.byteLength(body);
+          hasContentLength = true;
+        }
+        else if (config.autoChunked) {
+          headers["Transfer-Encoding"] = "chunked";
+          hasTransferEncoding = true;
+          var originalBody = body;
+          body = new Stream();
+          body.readable = true;
+
+          originalBody.on("data", function (chunk) {
+            if (Buffer.isBuffer(chunk)) {
+              body.emit("data", chunk.length.toString(16).toUpperCase() + "\r\n");
+              body.emit("data", chunk);
+              body.emit("data", "\r\n");
+              return;
+            }
+            var length = Buffer.byteLength(chunk);
+            body.emit("data", toString(16).toUpperCase() + "\r\n" + chunk + "\r\n");
+          });
+
+          originalBody.on("end", function () {
+            body.emit("data", "0\r\n\r\n\r\n");
+            body.emit("end")
+          });
+        }
+      }
+
+      if (config.autoConnection) {
+        if (req.shouldKeepAlive && (hasContentLength || hasTransferEncoding || statusCode == 304)) {
+          headers["Connection"] = "keep-alive"
+        }
+        else {
+          headers["Connection"] = "close"
+          req.shouldKeepAlive = false
+        }
+      }
+
+      var reasonPhrase = STATUS_CODES[statusCode];
+      if (!reasonPhrase) {
+        throw new Error("Invalid response code " + statusCode);
+      }
+      var head = "HTTP/1.1 " + statusCode + " " + reasonPhrase + "\r\n";
+      for (var key in headers) {
+        head += key + ": " + headers[key] + "\r\n";
+      }
+      head += "\r\n";
+
+      if (body && !isStreaming) head += body;
+
+      client.write(head);
+
+      if (!isStreaming) {
+        return done()
+      }
+
+      body.pipe(client);
+      body.on("end", done);
+
+    }
+
+    function done() {
+      if (req.shouldKeepAlive) {
+        parser.reinitialize(HTTPParser.REQUEST);
+      }
+      else {
+        client.end();
+      }
+    }
+
+    parser.onHeadersComplete = function (info) {
+      info.body = new Stream();
+      info.body.readable = true;
+      req = info;
+      var rawHeaders = req.rawHeaders = req.headers;
+      var headers = req.headers = {};
+      for (var i = 0, l = rawHeaders.length; i < l; i += 2) {
+        headers[rawHeaders[i].toLowerCase()] = rawHeaders[i + 1];
+      }
+      req.url = urlParse(req.url);
+      app(req, res);
+    }
+
+    parser.onBody = function (buf, start, len) {
+      req.body.emit("data", buf.slide(start, len));
+    };
+
+    parser.onMessageComplete = function () {
+      req.body.emit("end");
+    };
+
+    client.on("data", function (chunk) {
+      var ret = parser.execute(chunk, 0, chunk.length);
+      // TODO: handle error cases in ret
+    });
+
+    client.on("end", function () {
+      parser.finish();
+    });
+
+  };
+};

package/backend/node_modules/wrappy/LICENSE

@@ -0,0 +1,15 @@
+The ISC License
+
+Copyright (c) Isaac Z. Schlueter and Contributors
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR
+IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

package/backend/node_modules/wrappy/README.md

@@ -0,0 +1,36 @@
+# wrappy
+
+Callback wrapping utility
+
+## USAGE
+
+```javascript
+var wrappy = require("wrappy")
+
+// var wrapper = wrappy(wrapperFunction)
+
+// make sure a cb is called only once
+// See also: http://npm.im/once for this specific use case
+var once = wrappy(function (cb) {
+  var called = false
+  return function () {
+    if (called) return
+    called = true
+    return cb.apply(this, arguments)
+  }
+})
+
+function printBoo () {
+  console.log('boo')
+}
+// has some rando property
+printBoo.iAmBooPrinter = true
+
+var onlyPrintOnce = once(printBoo)
+
+onlyPrintOnce() // prints 'boo'
+onlyPrintOnce() // does nothing
+
+// random property is retained!
+assert.equal(onlyPrintOnce.iAmBooPrinter, true)
+```

package/backend/node_modules/wrappy/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "wrappy",
+  "version": "1.0.2",
+  "description": "Callback wrapping utility",
+  "main": "wrappy.js",
+  "files": [
+    "wrappy.js"
+  ],
+  "directories": {
+    "test": "test"
+  },
+  "dependencies": {},
+  "devDependencies": {
+    "tap": "^2.3.1"
+  },
+  "scripts": {
+    "test": "tap --coverage test/*.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/npm/wrappy"
+  },
+  "author": "Isaac Z. Schlueter <i@izs.me> (http://blog.izs.me/)",
+  "license": "ISC",
+  "bugs": {
+    "url": "https://github.com/npm/wrappy/issues"
+  },
+  "homepage": "https://github.com/npm/wrappy"
+}

package/backend/node_modules/wrappy/wrappy.js

@@ -0,0 +1,33 @@
+// Returns a wrapper function that returns a wrapped callback
+// The wrapper function should do some stuff, and return a
+// presumably different callback function.
+// This makes sure that own properties are retained, so that
+// decorations and such are not lost along the way.
+module.exports = wrappy
+function wrappy (fn, cb) {
+  if (fn && cb) return wrappy(fn)(cb)
+
+  if (typeof fn !== 'function')
+    throw new TypeError('need wrapper function')
+
+  Object.keys(fn).forEach(function (k) {
+    wrapper[k] = fn[k]
+  })
+
+  return wrapper
+
+  function wrapper() {
+    var args = new Array(arguments.length)
+    for (var i = 0; i < args.length; i++) {
+      args[i] = arguments[i]
+    }
+    var ret = fn.apply(this, args)
+    var cb = args[args.length-1]
+    if (typeof ret === 'function' && ret !== cb) {
+      Object.keys(cb).forEach(function (k) {
+        ret[k] = cb[k]
+      })
+    }
+    return ret
+  }
+}