streams: make streams lazy by default

lib/_stream_duplex.js

@@ -27,6 +27,8 @@ function Duplex(options) {
   Readable.call(this, options);
   Writable.call(this, options);
 
+  this._options = this._options;
+
   if (options && options.readable === false)
     this.readable = false;
 
@@ -40,6 +42,23 @@ function Duplex(options) {
   this.once('end', onend);
 }
 
+Object.defineProperty(Duplex.prototype, '_writableState', {
+  get: function() {
+    this._writableState = new Writable.WritableState(this._options, this);
+    return this._writableState;
+  },
+  set: function(val) {
+    Object.defineProperty(this, '_writableState', {
+      value: val,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  },
+  configurable: true,
+  enumerable: false
+});
+
 // the no-half-open enforcer
 function onend() {
   // if we allow half-open state, or if the writable side ended,

lib/_stream_readable.js

@@ -80,14 +80,31 @@ function Readable(options) {
   if (!(this instanceof Readable))
     return new Readable(options);
 
-  this._readableState = new ReadableState(options, this);
+  this._options = options;
 
   // legacy
   this.readable = true;
 
   Stream.call(this);
 }
 
+Object.defineProperty(Readable.prototype, '_readableState', {
+  get: function() {
+    this._readableState = new ReadableState(this._options, this);
+    return this._readableState;
+  },
+  set: function(val) {
+    Object.defineProperty(this, '_readableState', {
+      value: val,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  },
+  configurable: true,
+  enumerable: true
+});
+
 // Manually shove something into the read() buffer.
 // This returns true if the highWaterMark has not been hit yet,
 // similar to how Writable.write() returns true if you should

lib/_stream_transform.js

@@ -115,6 +115,22 @@ function Transform(options) {
   });
 }
 
+Object.defineProperty(Transform.prototype, '_transformState', {
+  get: function() {
+    this._transformState = new TransformState(this);
+    return this._transformState;
+  },
+  set: function(val) {
+    Object.defineProperty(this, '_transformState', {
+      value: val,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  },
+  configurable: true,
+  enumerable: true
+});
 Transform.prototype.push = function(chunk, encoding) {
   this._transformState.needTransform = false;
   return Duplex.prototype.push.call(this, chunk, encoding);

lib/_stream_writable.js

@@ -132,14 +132,32 @@ function Writable(options) {
   if (!(this instanceof Writable) && !(this instanceof Stream.Duplex))
     return new Writable(options);
 
-  this._writableState = new WritableState(options, this);
+  this._options = options;
 
   // legacy.
   this.writable = true;
 
   Stream.call(this);
 }
 
+
+Object.defineProperty(Writable.prototype, '_writableState', {
+  get: function() {
+    this._writableState = new WritableState(this._options, this);
+    return this._writableState;
+  },
+  set: function(val) {
+    Object.defineProperty(this, '_writableState', {
+      value: val,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  },
+  configurable: true,
+  enumerable: false
+});
+
 // Otherwise people can pipe Writable streams, which is just wrong.
 Writable.prototype.pipe = function() {
   this.emit('error', new Error('Cannot pipe. Not readable.'));

lib/crypto.js

@@ -40,35 +40,13 @@ const StringDecoder = require('string_decoder').StringDecoder;
 
 
 function LazyTransform(options) {
-  this._options = options;
+  options = options || {};
+  options.defaultEncoding = 'binary';
+  options.decodeStrings = false;
+  stream.Transform.call(this, options);
 }
 util.inherits(LazyTransform, stream.Transform);
 
-[
-  '_readableState',
-  '_writableState',
-  '_transformState'
-].forEach(function(prop, i, props) {
-  Object.defineProperty(LazyTransform.prototype, prop, {
-    get: function() {
-      stream.Transform.call(this, this._options);
-      this._writableState.decodeStrings = false;
-      this._writableState.defaultEncoding = 'binary';
-      return this[prop];
-    },
-    set: function(val) {
-      Object.defineProperty(this, prop, {
-        value: val,
-        enumerable: true,
-        configurable: true,
-        writable: true
-      });
-    },
-    configurable: true,
-    enumerable: true
-  });
-});
-
 
 exports.createHash = exports.Hash = Hash;
 function Hash(algorithm, options) {