Creating derived Read / Write streams.

lib/fs.js

@@ -52,6 +52,17 @@ const ConverterStream = CC("@mozilla.org/intl/converter-output-stream;1",
                            "nsIConverterOutputStream");
 const StreamCopier = CC("@mozilla.org/network/async-stream-copier;1",
                         "nsIAsyncStreamCopier");
+const StringStream = CC("@mozilla.org/io/string-input-stream;1",
+                        "nsIStringInputStream", "setData");
+
+const StreamReader = CC("@mozilla.org/binaryinputstream;1",
+                        "nsIBinaryInputStream", "setInputStream");
+const StreamWriter = CC("@mozilla.org/binaryoutputstream;1",
+                        "nsIBinaryOutputStream", "setOutputStream");
+
+const KEY = { valueOf: function valueOf() { return "Privates accessor" } };
+
+
 
 function toArray(enumerator) {
   let value = [];
@@ -70,6 +81,94 @@ function getFileChannel(file) {
 }
 
 
+function ReadStream(path) {
+  let fd = FileDescriptor(path);
+  let channel = getFileChannel(fd);
+  let emit = this._emit.bind(this);
+  channel.asyncOpen({
+    onDataAvailable: function onDataAvailable(request, context, inputStream, offset, length) {
+      try {
+        emit("data", new Buffer(StreamReader(inputStream).readByteArray(length)));
+      } catch (error) {
+        emit("error", error);
+      }
+    },
+    onStartRequest: function onStartRequest() { emit("start"); },
+    onStopRequest: function onStopRequest() { emit("end"); }
+  }, null);
+}
+ReadStream.prototype = Object.create(Stream.prototype, {
+  constructor: {
+    value: ReadStream
+  },
+  readable: {
+    value: true,
+    writable: true,
+    enumerable: true
+  },
+  setEncoding: {
+    value: function setEncoding(encoding) {
+      this.encoding = String(encoding).toUpperCase();
+    }
+  },
+  pause: {
+    value: function pause() {
+    }
+  },
+  resume: {
+    value: function resume() {
+    }
+  },
+  destroy: {
+    value: function destroy() {
+    }
+  }
+});
+
+function WriteStream(path) {
+  let emit = this._emit.bind(this);
+  let _ = {
+    fd: new FileDescriptor(path),
+    observer: {
+      onStartRequest: function onStartRequest() { emit("start"); },
+      onStopRequest: function onStopRequest() { emit("drain"); }
+    }
+  };
+  this.valueOf = function valueOf(key) { return key === KEY ? _ : this; };
+}
+WriteStream.prototype = Object.create(Stream.prototype, {
+  constructor: {
+    value: WriteStream
+  },
+  writable: {
+    value: true,
+    writable: true,
+    enumerable: true
+  },
+  write: {
+    value: function write(content) {
+      let { fd, observer } = this.valueOf(KEY);
+      let copier = new StreamCopier();
+      let target = new FileOutputStream();
+      target.init(fd, 0x04 | 0x08 | 0x20, parseInt("0666"),
+                  target.DEFER_OPEN);
+      let source = new StringStream(content, content.length);
+      copier.init(source, target, null, true, false, null, true, true);
+      copier.asyncCopy(observer, null);
+    },
+    enumerable: true
+  },
+  end: {
+    value: function end(content, encoding) {
+    },
+    enumerable: true
+  },
+  destroy: {
+    value: function destroy() {
+    }
+  }
+});
+
 function readdirSync(path) {
   return toArray(FileDescriptor(path).directoryEntries).map(getFileName);
 }
@@ -87,13 +186,9 @@ function readdir(path, callback) {
 exports.readdir = readdir;
 
 function readFile(path, callback) {
-  let fd = FileDescriptor(path);
-  let channel = getFileChannel(fd);
-  let stream = Stream();
-  let buffer = Buffer();
-  exports.stream = stream;
-  stream.open(channel);
-  stream.on("data", function(chunck) {
+  let buffer = new Buffer();
+  let stream = new ReadStream(path);
+    stream.on("data", function(chunck) {
     chunck.copy(buffer, buffer.length);
   });
   stream.on("error", callback);

lib/stream.js

@@ -1,29 +1,9 @@
 "use strict";
 
-const { Cc, Ci, components: { Constructor: CC } } = require("chrome");
-const { Buffer } = require("buffer");
 const { EventEmitterTrait: EventEmitter } = require("events");
-const StreamReader = CC("@mozilla.org/binaryinputstream;1",
-                        "nsIBinaryInputStream", "setInputStream");
 
-function Stream(channel) {
+function Stream() {
   return this instanceof Stream ? this : Object.create(Stream.prototype);
 }
 Stream.prototype = EventEmitter.create(Stream.prototype);
-Object.defineProperties(Stream.prototype, {
-  open: { value: function open(channel) {
-    let emit = this._emit.bind(this);
-    channel.asyncOpen({
-      onDataAvailable: function onData(request, context, inputStream, offset, length) {
-        try {
-          emit("data", new Buffer(StreamReader(inputStream).readByteArray(length)));
-        } catch (error) {
-          emit("error", error);
-        }
-      },
-      onStartRequest: function onStartRequest() { emit("start"); },
-      onStopRequest: function onStopRequest() { emit("end"); }
-    }, null);
-  }}
-});
 exports.Stream = Stream;