First commit

hGameTest/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)

hGameTest/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();
+};

hGameTest/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);
+};

hGameTest/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("");
+};

hGameTest/node_modules/memory-fs/package.json

@@ -0,0 +1,72 @@
+{
+  "_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": [
+    "/enhanced-resolve",
+    "/webpack",
+    "/webpack-dev-middleware"
+  ],
+  "_resolved": "https://registry.npmjs.org/memory-fs/-/memory-fs-0.4.1.tgz",
+  "_shasum": "3a9a20b8462523e447cfbc7e8bb80ed667bfc552",
+  "_spec": "memory-fs@~0.4.1",
+  "_where": "/home/andreas/Documents/Projects/haxe/openfl/nigger/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"
+}