Calling gate with an array of functions about asynquence HOT 6 CLOSED

So it actually seems like the .gate() step is completing all of it's steps successfully. However, it isn't bundling the messages from the completion triggers together into an array like the example in the README suggests. The arguments object looks like this:

{ '0': { [Function: a] fail: [Function], abort: [Function] },
  '1': 
   { /* config object */ },
  '2': 
   { /* config object */ },
  '3': 
   { /* config object */ }
}

from asynquence.

Your functionality is mostly correct, but just a slight misunderstanding of how the arguments will arrive after a gate. The message(s) from each gate-segment will respectively take up one positional argument to the next sequence step's callback. If a gate-segment sends one message, then it will just be one argument. If a gate-segment sends 2 or more messages, then in that positional argument, there will be an array of the messages that gate-segment sent. Example:

ASQ()
.gate(
   function(done) {    done("1","2");  },
   function(done) {    done("3");  },
   function(done) {    done("4","5"); }
})
.val(function(){ // <-- Notice: `val` instead of `then`
   var messages = Array.prototype.slice.call(arguments);
   console.log(JSON.stringify(messages);   // [  ["1","2"], "3", ["4","5"]  ]
});

A few notes:

1. I used val() instead of then() because I don't need the done parameter, and everything in that step will execute synchronously (just outputting). If I had used then(), the behavior would have been the same except the done callback would have been on the beginning of the arguments array. We'd have wanted to ditch it by calling messages.shift(), for example. I saved that mess by using val() which skips the done callback and only passes in messages.

   If, at the end of the val() call, you want to pass on another message to the next step in the chain, you can just return that message, and it will implicitly be passed along. You can only pass along one message this way.

2. A positional argument is only an array if that corresponding gate-segment sent more than one message. Otherwise, the message itself would be in that positional argument.

3. If a gate-segment sends no message, undefined will be in that corresponding positional argument.

from asynquence.

Ah I see. I should have noticed that. Thanks for the writeup.

from asynquence.

BTW, here's some suggested "improvements" to the organization to take advantage of some of asynquence API functionality.

function getEndpointConfig(endpoint) {
    return ASQ()
        .then(function(done){
            endpoint.getConfig(function(err,config){
                if (err) {
                    done.fail(err);
                }
                else {
                    config.id = endpoint.id;
                    console.log(config.id); 
                    done(config);
                }
            });
        })
    ;
}

// ASQ-chain
.seq(function(endpoints) {   // for this example, endpoints is an array of two object.
    var calls = [];
    endpoints.forEach(function(endpoint) {
        calls
        .push(function(done) {
            getEndpointConfig(endpoint).pipe(done); // <-- Notice: `pipe`
        });
    });
    return ASQ()
        .gate.apply(this,calls)
    ;
})
.val(function() { // <-- Notice: `val` instead of `then`
    var configs = Array.prototype.slice.call(arguments);
    console.log(configs);
    var configMap = _.pluck(configs, 'id');
    console.log(configMap);
})
.or(function(err){
    console.log(err);
});

Some notes:

1. I use done.fail(...) to signal an error into the chain, and then at the bottom of the chain, I "catch" any of those with the or(..) handler.
2. I use val() here again, same reasons as given before
3. I pushed the implementation of the config-fetching into its own getEndpointConfig() function, and then had it return a sequence, then I used pipe(done) to wire up both the message and error channels from that sequence back into the main sequence.

from asynquence.

Also, I just updated the README to try to clarify the way gate messages (in and out) work... can you see if this helps makes it clearer?

881424b

from asynquence.

Looks good! Thanks for the clarification. I took your advice on that refactor as well, much cleaner.

from asynquence.