first commit

Author: laino

Diff for: README.md

@@ -0,0 +1,24 @@
+writeable-buffer
+================
+
+A Writeable that buffers all data it receives up to `maxBufferSize` (default 10 MB).
+
+If `.toString([[encoding,] callback])` or `toBuffer([callback])` are called with a callback,
+they become asynchronous and wait until the stream has been ended with stream.end() or
+an error occured. Without a callback they return all data buffered at that time.
+
+Usage:
+
+```js
+const WritableBuffer = require('writeable-buffer');
+
+const buffer = new WritableBuffer({
+    maxBufferSize: 5000, // Only buffer up to 5kb
+});
+
+stream.pipe(buffer, { end : true });
+
+buffer.toString('utf8', (error, string) => {
+    console.log(string);
+});
+```

Diff for: index.js

@@ -0,0 +1,74 @@
+const stream = require('stream');
+const async = require('async');
+
+class StreamBuffer extends stream.Writable {
+    constructor(options) {
+        super(options);
+
+        options = options || {};
+
+        this.maxBufferSize = options.maxBufferSize || StreamBuffer.MAX_BUFFER_SIZE;
+
+        this.buffered = [];
+        this.bufferedAmount = 0;
+
+        this.hadError = null;
+        this.didFinish = false;
+
+        this.once('finish', () => this.didFinish = true);
+        this.once('error', (error) => this.hadError = error);
+    }
+
+    _write(chunk, encoding, callback) {
+        if (this.bufferedAmount === this.maxBufferSize)
+            return setImmediate(callback);
+
+        if (this.bufferedAmount + chunk.length > this.maxBufferSize) {
+            chunk = chunk.slice(0, this.maxBufferSize - this.bufferedAmount);
+        }
+
+        this.bufferedAmount += chunk.length;
+
+        this.buffered.push(chunk);
+
+        setImmediate(callback);
+    }
+
+    toString(encoding, callback) {
+        if (typeof encoding === 'function') {
+            callback = encoding;
+            encoding = 'utf8';
+        }
+
+        encoding = encoding || 'utf8';
+
+        if (!callback) {
+            return this.toBuffer().toString(encoding);
+        }
+
+        this.toBuffer((error, buffer) => {
+            if (error) return callback(error);
+
+            callback(null, buffer.toString(encoding));
+        });
+    }
+
+    toBuffer(callback) {
+        if (!callback) {
+            return Buffer.concat(this.buffered);
+        }
+
+        if (this.hadError || this.didFinish) {
+            return setImmediate(callback, this.hadError, this.toBuffer());
+        }
+
+        async.race([
+            (callback) => this.on('error', callback),
+            (callback) => this.on('finish', () => callback(null, this.toBuffer()))
+        ], callback);
+    }
+}
+
+StreamBuffer.MAX_BUFFER_SIZE = 10 * 1024 * 1024;
+
+module.exports = StreamBuffer;

Diff for: package.json

@@ -0,0 +1,8 @@
+{
+  "name": "writeable-buffer",
+  "version": "1.0.0",
+  "author": "laino",
+  "dependencies": {
+    "async": ""
+  }
+}