nodejs-twisted-deferreds's Introduction

Direct port of python's Twisted Deferred module to coffeescript and thus javascript.

Links:

Twisted Docs

Installation

git clone git://github.com/my8bird/nodejs-twisted-deferreds.git 
cd nodejs-twisted-deferreds
(sudo) npm link

Dependencies:

coffeescript
nodeunit (for running the tests)

Usage

This is a contrived example that reads the contents of a file, trims the whitespace and prints the result to the console. If an error occurs then it is logged.

fs    = require('fs')
defer = require('twisted-deferred')
Deferred = defer.Deferred

# Create Deferred instance that will track the steps
d = new Deferred()

# Add a step that cleans the content
d.addCallback (content) ->
    return content.trim()

# Add a step that uses the cleaned content
d.addCallback (cleanedContent) ->
    console.log cleanedContent

# If there is an error at any step make sure it is logged.
d.addErrback (err) ->
    console.error err

# Grab the content from the file and start the procedure
fs.readFile "path", "r", (err, data) ->
    if err
        d.errback err
    else
        d.callback data

It is also possible to wrap existing async code using the toDeferred method: d = defer.toDeferred(fs.readFile, "path") d.addCallback (content) -> console.log content d.addErrback (err) -> # log err

Tests

To run the tests ensure that nodeunit is installed. Then run run-tests.sh.

nodejs-twisted-deferreds's People

Contributors

Stargazers

Watchers

nodejs-twisted-deferreds's Issues

Feature idea - support Twisted's additional constructor arguments to DeferredList

It might be nice to support Twisted's DeferredList's additional arguments:

fireOnOneCallback
fireOnOneErrback
consumeErrors

switch tests to mocha

chainDeferred uses unbound methods when connecting callback chain

This results in the chain calling methods where this is null causing many issues.

If some Deferred using as value of second Deferred - not need call callback of second Deferred

Hello.
Sorry for my very bad english.

I have a code like this:

var twisted = require('twisted-deferred');
var a = new twisted.Deferred();
a.addCallbacks(function(a) {
    console.log('a = ' + a);
});
var b = new twisted.Deferred();
b.addCallbacks(function(b) {
    console.log('b = ' + b);
});
console.log('start');
a.callback(b);
console.log('process');
b.callback(123)
console.log('end');

And I expect as result this:

start
process
b = 123
a = 123
end

But keep this:

start
a = [object Object]
process
b = 123
end

In other words, if i set value to Deferred a as another Deferred b, not need call callback for a, until b is unknown

I believe that tцisted and works, but I could be wrong

Feature idea - provide `inlineCallbacks` decorator for JS environments that support `yield`

I haven't thought this through, but if yield is supported (see http://syzygy.st/javascript-coroutines/), then I think it is entirely possible to create an inlineCallbacks decorator similar to Twisted's, which may be way cool.

Recommend Projects