Merge branch 'stream'

Conflicts:
	lib/MemoryFileSystem.js
	package.json

Author: sokra

lib/MemoryFileSystem.js

@@ -5,6 +5,10 @@
 
 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)
@@ -213,6 +217,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,14 +25,16 @@
     "url": "https://github.com/webpack/memory-fs/issues"
   },
   "homepage": "https://github.com/webpack/memory-fs",
-  "dependencies": {
-    "errno": "^0.1.3"  
-  },
   "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"
+  },
+  "dependencies": {
+    "errno": "^0.1.3",
+    "readable-stream": "^2.0.1"
   }
 }

test/MemoryFileSystem.js

@@ -1,3 +1,4 @@
+var bl = require("bl");
 var should = require("should");
 var MemoryFileSystem = require("../lib/MemoryFileSystem");
 
@@ -231,6 +232,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(done) {
+			var fs = new MemoryFileSystem();
+			fs.writeFileSync("/file", "Hello");
+			fs.createReadStream("/file").pipe(bl(function(err, data) {
+				data.toString('utf8').should.be.eql("Hello");
+				done();
+			}));
+		});
+		it("should respect start/end", function(done) {
+			var fs = new MemoryFileSystem();
+			fs.writeFileSync("/file", "Hello");
+			fs.createReadStream("/file", {
+				start: 1,
+				end: 3
+			}).pipe(bl(function(err, data) {
+				data.toString('utf8').should.be.eql("el");
+				done();
+			}));
+		});
+		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();