https://github.com/tootallnate/node-stream-stack

Filter low-level `Stream` instances into stackable, protocol-based streams.
https://github.com/tootallnate/node-stream-stack

Last synced: 22 days ago
JSON representation

Filter low-level `Stream` instances into stackable, protocol-based streams.

• Host: GitHub
• URL: https://github.com/tootallnate/node-stream-stack
• Owner: TooTallNate
• License: mit
• Created: 2010-10-31T08:06:04.000Z (about 14 years ago)
• Default Branch: master
• Last Pushed: 2012-05-04T16:16:39.000Z (over 12 years ago)
• Last Synced: 2024-12-10T14:05:01.031Z (about 1 month ago)
• Language: JavaScript
• Homepage: http://tootallnate.net/implementing-your-protocol-stack-with-stream-stacks
• Size: 916 KB
• Stars: 28
• Watchers: 6
• Forks: 4
• Open Issues: 0
• Metadata Files:
  • Readme: README.md
  • License: LICENSE

Awesome Lists containing this project

README

        
node-stream-stack

=================

### Filter low-level `Stream` instances into stackable, protocol-based streams.

This module exposes the `StreamStack` interface, which starts off as a node

`Stream` subclass that accepts a "parent" Stream to work with. `StreamStack` is

meant to be subclassed in order to implement the layers of a protocol, or run the

parent Stream's data through some kind of filter (i.e. compression).

By default, a `StreamStack` instance proxies all events downstream (from the

parent stream to the child stream), and proxies all functions calls upstream

(from the child stream to the parent stream).

Keeping the `StreamStack` subclass' implementation independent of the parent

`Stream` instance allows for the backend transport to be easily swapped out

for flexibility and code re-use. For example, storing `netcat` results to a file,

and using `fs.ReadStream` as your parent stream, rather than `net.Stream`, in your

test cases.

Since `StreamStack` inherits from the regular node `Stream`, all it's prototypal

goodies can be used along with your subclass instances. This makes it extremely

easy for you to call `Stream#pipe(writable)`, in order to utilize node's data

transfer philosophies.

A Simple Example

----------------

Here's a simple, kinda silly example:

``` js

var util = require('util');

var StreamStack = require('stream-stack').StreamStack;

// The first argument is the parent stream

function DoubleWrite(stream) {

  StreamStack.call(this, stream);

}

util.inherits(DoubleWrite, StreamStack);

// Overwrite the default `write()` function to call

// write() on the parent stream twice!

DoubleWrite.prototype.write = function(data) {

  this.stream.write(data);

  this.stream.write(data);

}

// How to Use:

var doubleStdout = new DoubleWrite(process.stdout);

doubleStdout.write("this will be printed twice!\n");

```

We've defined a `DoubleWrite` class. It accepts a writable stream, and

whenever `write()` is called on the DoubleWrite instance, then in return

`write()` get called _twice_ on the parent stream. In this example, our

writable stream, `process.stdout`, will get the string printed to it twice.

Known Subclasses

----------------

Check out the [Wiki][] page to see the list of [Known Subclasses][Wiki].

[Wiki]: https://github.com/TooTallNate/node-stream-stack/wiki