api, login, auth

5 files changed, 528 insertions, 0 deletions

diff --git a/node_modules/memory-fs/README.md b/node_modules/memory-fs/README.md
new file mode 100644
index 0000000..d4542c0
--- /dev/null
+++ b/node_modules/memory-fs/README.md
@@ -0,0 +1,29 @@
+# memory-fs

+

+A simple in-memory filesystem. Holds data in a javascript object.

+

+``` javascript

+var MemoryFileSystem = require("memory-fs");

+var fs = new MemoryFileSystem(); // Optionally pass a javascript object

+

+fs.mkdirpSync("/a/test/dir");

+fs.writeFileSync("/a/test/dir/file.txt", "Hello World");

+fs.readFileSync("/a/test/dir/file.txt"); // returns Buffer("Hello World")

+

+// Async variants too

+fs.unlink("/a/test/dir/file.txt", function(err) {

+	// ...

+});

+

+fs.readdirSync("/a/test"); // returns ["dir"]

+fs.statSync("/a/test/dir").isDirectory(); // returns true

+fs.rmdirSync("/a/test/dir");

+

+fs.mkdirpSync("C:\\use\\windows\\style\\paths");

+```

+

+## License

+

+Copyright (c) 2012-2014 Tobias Koppers

+

+MIT (http://www.opensource.org/licenses/mit-license.php)

diff --git a/node_modules/memory-fs/lib/MemoryFileSystem.js b/node_modules/memory-fs/lib/MemoryFileSystem.js
new file mode 100644
index 0000000..7ef3f4c
--- /dev/null
+++ b/node_modules/memory-fs/lib/MemoryFileSystem.js
@@ -0,0 +1,329 @@
+/*

+	MIT License http://www.opensource.org/licenses/mit-license.php

+	Author Tobias Koppers @sokra

+*/

+

+var normalize = require("./normalize");

+var errors = require("errno");

+var stream = require("readable-stream");

+

+var ReadableStream = stream.Readable;

+var WritableStream = stream.Writable;

+

+function MemoryFileSystemError(err, path) {

+	Error.call(this)

+	if (Error.captureStackTrace)

+		Error.captureStackTrace(this, arguments.callee)

+	this.code = err.code;

+	this.errno = err.errno;

+	this.message = err.description;

+	this.path = path;

+}

+MemoryFileSystemError.prototype = new Error();

+

+function MemoryFileSystem(data) {

+	this.data = data || {};

+}

+module.exports = MemoryFileSystem;

+

+function isDir(item) {

+	if(typeof item !== "object") return false;

+	return item[""] === true;

+}

+

+function isFile(item) {

+	if(typeof item !== "object") return false;

+	return !item[""];

+}

+

+function pathToArray(path) {

+	path = normalize(path);

+	var nix = /^\//.test(path);

+	if(!nix) {

+		if(!/^[A-Za-z]:/.test(path)) {

+			throw new MemoryFileSystemError(errors.code.EINVAL, path);

+		}

+		path = path.replace(/[\\\/]+/g, "\\"); // multi slashs

+		path = path.split(/[\\\/]/);

+		path[0] = path[0].toUpperCase();

+	} else {

+		path = path.replace(/\/+/g, "/"); // multi slashs

+		path = path.substr(1).split("/");

+	}

+	if(!path[path.length-1]) path.pop();

+	return path;

+}

+

+function trueFn() { return true; }

+function falseFn() { return false; }

+

+MemoryFileSystem.prototype.meta = function(_path) {

+	var path = pathToArray(_path);

+	var current = this.data;

+	for(var i = 0; i < path.length - 1; i++) {

+		if(!isDir(current[path[i]]))

+			return;

+		current = current[path[i]];

+	}

+	return current[path[i]];

+}

+

+MemoryFileSystem.prototype.existsSync = function(_path) {

+	return !!this.meta(_path);

+}

+

+MemoryFileSystem.prototype.statSync = function(_path) {

+	var current = this.meta(_path);

+	if(_path === "/" || isDir(current)) {

+		return {

+			isFile: falseFn,

+			isDirectory: trueFn,

+			isBlockDevice: falseFn,

+			isCharacterDevice: falseFn,

+			isSymbolicLink: falseFn,

+			isFIFO: falseFn,

+			isSocket: falseFn

+		};

+	} else if(isFile(current)) {

+		return {

+			isFile: trueFn,

+			isDirectory: falseFn,

+			isBlockDevice: falseFn,

+			isCharacterDevice: falseFn,

+			isSymbolicLink: falseFn,

+			isFIFO: falseFn,

+			isSocket: falseFn

+		};

+	} else {

+		throw new MemoryFileSystemError(errors.code.ENOENT, _path);

+	}

+};

+

+MemoryFileSystem.prototype.readFileSync = function(_path, encoding) {

+	var path = pathToArray(_path);

+	var current = this.data;

+	for(var i = 0; i < path.length - 1; i++) {

+		if(!isDir(current[path[i]]))

+			throw new MemoryFileSystemError(errors.code.ENOENT, _path);

+		current = current[path[i]];

+	}

+	if(!isFile(current[path[i]])) {

+		if(isDir(current[path[i]]))

+			throw new MemoryFileSystemError(errors.code.EISDIR, _path);

+		else

+			throw new MemoryFileSystemError(errors.code.ENOENT, _path);

+	}

+	current = current[path[i]];

+	return encoding ? current.toString(encoding) : current;

+};

+

+MemoryFileSystem.prototype.readdirSync = function(_path) {

+	if(_path === "/") return Object.keys(this.data).filter(Boolean);

+	var path = pathToArray(_path);

+	var current = this.data;

+	for(var i = 0; i < path.length - 1; i++) {

+		if(!isDir(current[path[i]]))

+			throw new MemoryFileSystemError(errors.code.ENOENT, _path);

+		current = current[path[i]];

+	}

+	if(!isDir(current[path[i]])) {

+		if(isFile(current[path[i]]))

+			throw new MemoryFileSystemError(errors.code.ENOTDIR, _path);

+		else

+			throw new MemoryFileSystemError(errors.code.ENOENT, _path);

+	}

+	return Object.keys(current[path[i]]).filter(Boolean);

+};

+

+MemoryFileSystem.prototype.mkdirpSync = function(_path) {

+	var path = pathToArray(_path);

+	if(path.length === 0) return;

+	var current = this.data;

+	for(var i = 0; i < path.length; i++) {

+		if(isFile(current[path[i]]))

+			throw new MemoryFileSystemError(errors.code.ENOTDIR, _path);

+		else if(!isDir(current[path[i]]))

+			current[path[i]] = {"":true};

+		current = current[path[i]];

+	}

+	return;

+};

+

+MemoryFileSystem.prototype.mkdirSync = function(_path) {

+	var path = pathToArray(_path);

+	if(path.length === 0) return;

+	var current = this.data;

+	for(var i = 0; i < path.length - 1; i++) {

+		if(!isDir(current[path[i]]))

+			throw new MemoryFileSystemError(errors.code.ENOENT, _path);

+		current = current[path[i]];

+	}

+	if(isDir(current[path[i]]))

+		throw new MemoryFileSystemError(errors.code.EEXIST, _path);

+	else if(isFile(current[path[i]]))

+		throw new MemoryFileSystemError(errors.code.ENOTDIR, _path);

+	current[path[i]] = {"":true};

+	return;

+};

+

+MemoryFileSystem.prototype._remove = function(_path, name, testFn) {

+	var path = pathToArray(_path);

+	if(path.length === 0) {

+		throw new MemoryFileSystemError(errors.code.EPERM, _path);

+	}

+	var current = this.data;

+	for(var i = 0; i < path.length - 1; i++) {

+		if(!isDir(current[path[i]]))

+			throw new MemoryFileSystemError(errors.code.ENOENT, _path);

+		current = current[path[i]];

+	}

+	if(!testFn(current[path[i]]))

+		throw new MemoryFileSystemError(errors.code.ENOENT, _path);

+	delete current[path[i]];

+	return;

+};

+

+MemoryFileSystem.prototype.rmdirSync = function(_path) {

+	return this._remove(_path, "Directory", isDir);

+};

+

+MemoryFileSystem.prototype.unlinkSync = function(_path) {

+	return this._remove(_path, "File", isFile);

+};

+

+MemoryFileSystem.prototype.readlinkSync = function(_path) {

+	throw new MemoryFileSystemError(errors.code.ENOSYS, _path);

+};

+

+MemoryFileSystem.prototype.writeFileSync = function(_path, content, encoding) {

+	if(!content && !encoding) throw new Error("No content");

+	var path = pathToArray(_path);

+	if(path.length === 0) {

+		throw new MemoryFileSystemError(errors.code.EISDIR, _path);

+	}

+	var current = this.data;

+	for(var i = 0; i < path.length - 1; i++) {

+		if(!isDir(current[path[i]]))

+			throw new MemoryFileSystemError(errors.code.ENOENT, _path);

+		current = current[path[i]];

+	}

+	if(isDir(current[path[i]]))

+		throw new MemoryFileSystemError(errors.code.EISDIR, _path);

+	current[path[i]] = encoding || typeof content === "string" ? new Buffer(content, encoding) : content;

+	return;

+};

+

+MemoryFileSystem.prototype.join = require("./join");

+MemoryFileSystem.prototype.pathToArray = pathToArray;

+MemoryFileSystem.prototype.normalize = normalize;

+

+// stream functions

+

+MemoryFileSystem.prototype.createReadStream = function(path, options) {

+	var stream = new ReadableStream();

+	var done = false;

+	var data;

+	try {

+		data = this.readFileSync(path);

+	} catch (e) {

+		stream._read = function() {

+			if (done) {

+				return;

+			}

+			done = true;

+			this.emit('error', e);

+			this.push(null);

+		};

+		return stream;

+	}

+	options = options || { };

+	options.start = options.start || 0;

+	options.end = options.end || data.length;

+	stream._read = function() {

+		if (done) {

+			return;

+		}

+		done = true;

+		this.push(data.slice(options.start, options.end));

+		this.push(null);

+	};

+	return stream;

+};

+

+MemoryFileSystem.prototype.createWriteStream = function(path, options) {

+	var stream = new WritableStream(), self = this;

+	try {

+		// Zero the file and make sure it is writable

+		this.writeFileSync(path, new Buffer(0));

+	} catch(e) {

+		// This or setImmediate?

+		stream.once('prefinish', function() {

+			stream.emit('error', e);

+		});

+		return stream;

+	}

+	var bl = [ ], len = 0;

+	stream._write = function(chunk, encoding, callback) {

+		bl.push(chunk);

+		len += chunk.length;

+		self.writeFile(path, Buffer.concat(bl, len), callback);

+	}

+	return stream;

+};

+

+// async functions

+

+["stat", "readdir", "mkdirp", "rmdir", "unlink", "readlink"].forEach(function(fn) {

+	MemoryFileSystem.prototype[fn] = function(path, callback) {

+		try {

+			var result = this[fn + "Sync"](path);

+		} catch(e) {

+			setImmediate(function() {

+				callback(e);

+			});

+

+			return;

+		}

+		setImmediate(function() {

+			callback(null, result);

+		});

+	};

+});

+

+["mkdir", "readFile"].forEach(function(fn) {

+	MemoryFileSystem.prototype[fn] = function(path, optArg, callback) {

+		if(!callback) {

+			callback = optArg;

+			optArg = undefined;

+		}

+		try {

+			var result = this[fn + "Sync"](path, optArg);

+		} catch(e) {

+			setImmediate(function() {

+				callback(e);

+			});

+

+			return;

+		}

+		setImmediate(function() {

+			callback(null, result);

+		});

+	};

+});

+

+MemoryFileSystem.prototype.exists = function(path, callback) {

+	return callback(this.existsSync(path));

+}

+

+MemoryFileSystem.prototype.writeFile = function (path, content, encoding, callback) {

+	if(!callback) {

+		callback = encoding;

+		encoding = undefined;

+	}

+	try {

+		this.writeFileSync(path, content, encoding);

+	} catch(e) {

+		return callback(e);

+	}

+	return callback();

+};

diff --git a/node_modules/memory-fs/lib/join.js b/node_modules/memory-fs/lib/join.js
new file mode 100644
index 0000000..2814aa9
--- /dev/null
+++ b/node_modules/memory-fs/lib/join.js
@@ -0,0 +1,14 @@
+var normalize = require("./normalize");

+

+var absoluteWinRegExp = /^[A-Z]:([\\\/]|$)/i;

+var absoluteNixRegExp = /^\//i;

+

+module.exports = function join(path, request) {

+	if(!request) return normalize(path);

+	if(absoluteWinRegExp.test(request)) return normalize(request.replace(/\//g, "\\"));

+	if(absoluteNixRegExp.test(request)) return normalize(request);

+	if(path == "/") return normalize(path + request);

+	if(absoluteWinRegExp.test(path)) return normalize(path.replace(/\//g, "\\") + "\\" + request.replace(/\//g, "\\"));

+	if(absoluteNixRegExp.test(path)) return normalize(path + "/" + request);

+	return normalize(path + "/" + request);

+};

diff --git a/node_modules/memory-fs/lib/normalize.js b/node_modules/memory-fs/lib/normalize.js
new file mode 100644
index 0000000..72c3df0
--- /dev/null
+++ b/node_modules/memory-fs/lib/normalize.js
@@ -0,0 +1,86 @@
+module.exports = function normalize(path) {

+	var parts = path.split(/(\\+|\/+)/);

+	if(parts.length === 1)

+		return path;

+	var result = [];

+	var absolutePathStart = 0;

+	for(var i = 0, sep = false; i < parts.length; i++, sep = !sep) {

+		var part = parts[i];

+		if(i === 0 && /^([A-Z]:)?$/i.test(part)) {

+			result.push(part);

+			absolutePathStart = 2;

+		} else if(sep) {

+			result.push(part[0]);

+		} else if(part === "..") {

+			switch(result.length) {

+				case 0:

+					// i. e. ".." => ".."

+					// i. e. "../a/b/c" => "../a/b/c"

+					result.push(part);

+					break;

+				case 2:

+					// i. e. "a/.." => ""

+					// i. e. "/.." => "/"

+					// i. e. "C:\.." => "C:\"

+					// i. e. "a/../b/c" => "b/c"

+					// i. e. "/../b/c" => "/b/c"

+					// i. e. "C:\..\a\b\c" => "C:\a\b\c"

+					i++;

+					sep = !sep;

+					result.length = absolutePathStart;

+					break;

+				case 4:

+					// i. e. "a/b/.." => "a"

+					// i. e. "/a/.." => "/"

+					// i. e. "C:\a\.." => "C:\"

+					// i. e. "/a/../b/c" => "/b/c"

+					if(absolutePathStart === 0) {

+						result.length -= 3;

+					} else {

+						i++;

+						sep = !sep;

+						result.length = 2;

+					}

+					break;

+				default:

+					// i. e. "/a/b/.." => "/a"

+					// i. e. "/a/b/../c" => "/a/c"

+					result.length -= 3;

+					break;

+			}

+		} else if(part === ".") {

+			switch(result.length) {

+				case 0:

+					// i. e. "." => "."

+					// i. e. "./a/b/c" => "./a/b/c"

+					result.push(part);

+					break;

+				case 2:

+					// i. e. "a/." => "a"

+					// i. e. "/." => "/"

+					// i. e. "C:\." => "C:\"

+					// i. e. "C:\.\a\b\c" => "C:\a\b\c"

+					if(absolutePathStart === 0) {

+						result.length--;

+					} else {

+						i++;

+						sep = !sep;

+					}

+					break;

+				default:

+					// i. e. "a/b/." => "a/b"

+					// i. e. "/a/." => "/"

+					// i. e. "C:\a\." => "C:\"

+					// i. e. "a/./b/c" => "a/b/c"

+					// i. e. "/a/./b/c" => "/a/b/c"

+					result.length--;

+					break;

+			}

+		} else if(part) {

+			result.push(part);

+		}

+	}

+	if(result.length === 1 && /^[A-Za-z]:$/.test(result))

+		return result[0] + "\\";

+	return result.join("");

+};

diff --git a/node_modules/memory-fs/package.json b/node_modules/memory-fs/package.json
new file mode 100644
index 0000000..a69a5d3
--- /dev/null
+++ b/node_modules/memory-fs/package.json
@@ -0,0 +1,70 @@
+{
+  "_from": "memory-fs@^0.4.1",
+  "_id": "memory-fs@0.4.1",
+  "_inBundle": false,
+  "_integrity": "sha1-OpoguEYlI+RHz7x+i7gO1me/xVI=",
+  "_location": "/memory-fs",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "range",
+    "registry": true,
+    "raw": "memory-fs@^0.4.1",
+    "name": "memory-fs",
+    "escapedName": "memory-fs",
+    "rawSpec": "^0.4.1",
+    "saveSpec": null,
+    "fetchSpec": "^0.4.1"
+  },
+  "_requiredBy": [
+    "/webpack"
+  ],
+  "_resolved": "https://registry.npmjs.org/memory-fs/-/memory-fs-0.4.1.tgz",
+  "_shasum": "3a9a20b8462523e447cfbc7e8bb80ed667bfc552",
+  "_spec": "memory-fs@^0.4.1",
+  "_where": "/home/pruss/Dev/3-minute-website/node_modules/webpack",
+  "author": {
+    "name": "Tobias Koppers @sokra"
+  },
+  "bugs": {
+    "url": "https://github.com/webpack/memory-fs/issues"
+  },
+  "bundleDependencies": false,
+  "dependencies": {
+    "errno": "^0.1.3",
+    "readable-stream": "^2.0.1"
+  },
+  "deprecated": false,
+  "description": "A simple in-memory filesystem. Holds data in a javascript object.",
+  "devDependencies": {
+    "bl": "^1.0.0",
+    "codecov.io": "^0.1.4",
+    "coveralls": "^2.11.2",
+    "istanbul": "^0.2.13",
+    "mocha": "^1.20.1",
+    "should": "^4.0.4"
+  },
+  "directories": {
+    "test": "test"
+  },
+  "files": [
+    "lib/"
+  ],
+  "homepage": "https://github.com/webpack/memory-fs",
+  "keywords": [
+    "fs",
+    "memory"
+  ],
+  "license": "MIT",
+  "main": "lib/MemoryFileSystem.js",
+  "name": "memory-fs",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/webpack/memory-fs.git"
+  },
+  "scripts": {
+    "cover": "istanbul cover node_modules/mocha/bin/_mocha",
+    "test": "mocha",
+    "travis": "npm run cover -- --report lcovonly"
+  },
+  "version": "0.4.1"
+}