Skip to content

Neamar/rarity

Folders and files

NameName
Last commit message
Last commit date

Latest commit

 

History

45 Commits
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 

Repository files navigation

rarity

Build Status Coverage Status NPM version

Continuation tools for callbacks arity.

1 - Carry arguments

Here is some shitty code:

function(cb) {
    var aVar = 1;
    someFunction(function(err, result) {
        // Mix results from previous scope with new results
        cb(err, aVar, result);
    });
}

Here is some improved version, using rarity:

function(cb) {
    var aVar = 1;
    someFunction(rarity.carry([aVar], cb));
}

Arguments passed in the array will be carried between the first argument of the original callback (the error, in node convention) and all the others.

Documentation

rarity.carry(arrayOfArgumentsToAddBetweenErrorAndOriginal, cb)

If you pass something else than an array, it will be automatically wrapped in an array: rarity.carry(value, cb) => rarity.carry([value], cb) => cb(err, value, ...arguments)

2 - Slice arguments

Did you ever find yourself writing shitty code such as this one:

someShittyFunction(function(err, uselessArgument, anotherUselessArgument) {
    cb(err);
});

To minimize the quantity of arguments sent over to your next function (async.waterfall anyone?)

rarity allow you to easily control this behavior:

// Generate a wrapper function around cb, only forwarding the first parameter.
someShittyFunction(rarity.slice(1, cb));

Documentation

rarity.slice(maxNumberOfArgumentsToForward, cb)

Without rarity

var async = require('async');

async.waterfall([
    function callShittyLib(cb) {
        someShittyFunction(cb);
    },
    function handleResults(result, uselessArgument, anotherUselessArgument, cb) {
        // When writing your function, you need to check the documentation regarding the number of arguments you'll receive.
        // Boring.
        stuff();
        cb();
    }
], process.exit);

With rarity

var async = require('async');
var rarity = require('rarity');

async.waterfall([
    function callShittyLib(cb) {
        // Slice after the first two arguments (err and results), discard all others
        someShittyFunction(rarity.slice(2, cb));
    },
    function handleResults(result, cb) {
        // We only get result, not the other parameters (err was handled by the `async` lib)
        stuff();
        cb();
    }
], process.exit);

3 - Pad arguments

When using some shitty-backported lib, for instance factory-lady, you'll need to pad your queries with a first additional argument representing a fake error, making it compatible with all the node ecosystem.

The following code:

someShittyFunction(function(result) {
    cb(null, result);
});

Will become, using rarity:

// Wraps cb with a new function, sending null as the first argument.
someShittyFunction(rarity.pad([null], cb));

Documentation

rarity.pad(arrayOfArgumentsToPad, cb)

4 - Carry and slice

Specific use case, combining rarity.carry and rarity.slice:

The following code:

function(cb) {
    var aVar = 1;
    someFunction(function(err, result, useless) {
        cb(err, aVar, result);
    });
}

Will become, using rarity:

function(cb) {
    var aVar = 1;
    someFunction(rarity.carryAndSlice([aVar], 3, cb));
}

Documentation

rarity.carryAndSlice(arrayOfArgumentsToAddBetweenErrorAndOriginal, maxNumberOfArgumentsToForward, cb)

Installation

npm install rarity

You're done. Now go write some shitty code.

Why the shitty name?

rarity is short for reduce arity. Also, arity was already created on npm.