FM / culvert

/usr/local/lib/node_modules/pm2/node_modules/culvert/

/usr/local/lib/node_modules/pm2/node_modules/culvert

Name	Size	Mode	Actions
channel.js	1505	0644	edit dl rm
consume.js	329	0644	edit dl rm
LICENSE	1077	0644	edit dl rm
package.json	594	0644	edit dl rm
README.md	2611	0644	edit dl rm

Edit: /usr/local/lib/node_modules/pm2/node_modules/culvert/README.md (2611B)

Culvert
=======

Channel for easy streaming of work between complex logics.

This is used in place of streams for CSP style flow.  I use it in js-git for network and file streams.

Usually, you'll want to split sides to create a duplex channel.

```js
var makeChannel = require('culvert');

var serverChannel = makeChannel();
var clientChannel = makeChannel();

function connect(host, port) {

// This represents the server-side of the duplex pipe
  var socket = {
    put: serverChannel.put,
    drain: serverChannel.drain,
    take: cientChannel.drain
  };

// When we want to send data to the consumer...
  socket.put(someData);

// When we want to read from the consumer...
  socket.take(function (err, item) {});

// Return the client's end of the pipe
  return {
    put: clientChannel.put,
    drain: clientChannel.drain,
    take: serverChannel.take
  };
}
```

If you want/need to preserve back-pressure and honor the buffer limit,
make sure to wait for drain when `put` returns false.

```js
// Start a read
socket.take(onData);

function onDrain(err) {
  if (err) throw err;
  // Resume reading
  socket.take(onData);
}
```

If you're using continuables and generators, it's much nicer syntax.

```js
var item;
while (item = yield socket.take, item !== undefined) {
  if (!socket.put(item)) yield socket.drain;
}
console.log("done");
```

Also the continuable version won't blow the stack if lots of events come in on the same tick.

## makeChannel(bufferSize, monitor)

Create a new channel.

The optional bufferSize is how many items can be in the queue and still be considered not full.

The optional monitor function will get called with `(type, item)` where `type` is either "put" or "take" and `item` is the value being put or taken.

## channel.put(item) -> more

This is a sync function.  You can add as many items to the channel as you want and it will queue them up.

This returns `true` when the queue is smaller than bufferSize, it returns false if you should wait for drain.

## channel.drain(callback)

Drain is a reusable continuable.  Use this when you want to wait for the buffer to be below the bufferSize mark.

## channel.take(callback)

Take is for reading.  The callback will have the next item.  It may call sync or it may be later.

cmd: