Support createReadStream and createWriteStream.

Preliminary support for the functions by the same name from the `fs` module.

Author: izaakschroeder

lib/MemoryFileSystem.js

@@ -4,6 +4,10 @@
 */
 
 var normalize = require("./normalize");
+var stream = require("stream");
+
+var ReadableStream = stream.Readable;
+var WritableStream = stream.Writable;
 
 function MemoryFileSystem(data) {
 	this.data = data || {};
@@ -185,6 +189,60 @@ MemoryFileSystem.prototype.join = require("./join");
 
 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", "mkdir", "rmdir", "unlink", "readlink"].forEach(function(fn) {

package.json

@@ -25,6 +25,7 @@
   },
   "homepage": "https://github.com/webpack/memory-fs",
   "devDependencies": {
+    "bl": "^1.0.0",
     "istanbul": "^0.2.13",
     "mocha": "^1.20.1",
     "should": "^4.0.4"

test/MemoryFileSystem.js

@@ -1,3 +1,4 @@
+var bl = require("bl");
 var should = require("should");
 var MemoryFileSystem = require("../lib/MemoryFileSystem");
 
@@ -224,6 +225,78 @@ describe("async", function() {
 		});
 	});
 });
+describe("streams", function() {
+	describe("writable streams", function() {
+		it("should write files", function() {
+			var fs = new MemoryFileSystem();
+			fs.createWriteStream("/file").end("Hello");
+			fs.readFileSync("/file", "utf8").should.be.eql("Hello");
+		});
+		it("should zero files", function() {
+			var fs = new MemoryFileSystem();
+			fs.createWriteStream("/file").end();
+			fs.readFileSync("/file", "utf8").should.be.eql("");
+		});
+		it("should accept pipes", function(done) {
+			// TODO: Any way to avoid the asyncness of this?
+			var fs = new MemoryFileSystem();
+			bl(new Buffer("Hello"))
+				.pipe(fs.createWriteStream("/file"))
+				.once('finish', function() {
+					fs.readFileSync("/file", "utf8").should.be.eql("Hello");
+					done();
+				});
+		});
+		it("should propagate errors", function(done) {
+			var fs = new MemoryFileSystem();
+			var stream = fs.createWriteStream("file");
+			var err = false;
+			stream.once('error', function() {
+				err = true;
+			}).once('finish', function() {
+				err.should.eql(true);
+				done();
+			});
+			stream.end();
+		});
+	});
+	describe("readable streams", function() {
+		it("should read files", function() {
+			var fs = new MemoryFileSystem();
+			fs.writeFileSync("/file", "Hello");
+			bl(fs.createReadStream("/file"), function(err, data) {
+				err.should.eql(undefined);
+				data.should.eql("Hello");
+			});
+		});
+		it("should respect start/end", function() {
+			var fs = new MemoryFileSystem();
+			fs.writeFileSync("/file", "Hello");
+			bl(fs.createReadStream("/file", {
+				start: 2,
+				end: 4
+			}), function(err, data) {
+				err.should.eql(undefined);
+				data.should.eql("el");
+			});
+		});
+		it("should propagate errors", function(done) {
+			var fs = new MemoryFileSystem();
+			var stream = fs.createReadStream("file");
+			var err = false;
+			// Why does this dummy event need to be here? It looks like it
+			// either has to be this or data before the stream will actually
+			// do anything.
+			stream.on('readable', function() { }).on('error', function() {
+				err = true;
+			}).on('end', function() {
+				err.should.eql(true);
+				done();
+			});
+			stream.read(0);
+		});
+	});
+});
 describe("normalize", function() {
 	it("should normalize paths", function() {
 		var fs = new MemoryFileSystem();
@@ -359,4 +432,4 @@ describe("os", function() {
 			fileSystem.statSync("C:\\a/dir\\index").isFile().should.be.eql(true);
 		});
 	});
-});
+});