sc-useify

Useify

---

Useify is a middleware implementation that extends objects.

Example

// var Useify = require( "Useify" ),
//   should = require( "should" );
 
var MyClass = function () {
  this.hasInitialised = false;
  this.value = 0;
}
 
MyClass.prototype.init = function () {
  this.hasInitialised = true;
  this.middleware( "postInit", function () {
    this.execute();
  } );
};
 
MyClass.prototype.execute = function () {
  this.middleware( function ( _sum ) {
 
    this.hasInitialised.should.be.true;
    should( _sum ).equal( 22 );
    _done();
 
  }, 1, 2 );
}
 
// `Useify` the class
Useify( MyClass );
 
// Adds the first middleware function.
MyClass.use( function ( _one, _two, _next ) {
 
  // The context `this` is a reference to the context class. In this example it is `myClass`
  var aValue = myClass.value + _one + _two;
 
  // Trigger the callback when this functions tasks are complete. Pass a dynmaic amount of
  // arguments to the next function.
  _next( aValue );
 
} );
 
// Adds the second middleware function. Note that the first argument is the paramater from the
// previous middleware function. The last argument should always be the callback to the next
// middleware function.
MyClass.use( function ( _three, _next ) {
 
  _next( _three, 4 );
 
} ).use( function ( _three, _four, _next ) { // `use` can be chained
 
  _next( _three + _four + 5 );
 
} );
 
// This is a named middleware function. By default, middleware functions are named "all". This
// will give you the ability to add multiple middleware injection points.
MyClass.use( "postInit", function ( _next ) {
 
  this.value = 10;
  _next();
 
} );
 
// Runs the middleware queue of functions. The last argument of `run` is a callback that is 
// triggered after the queue is emptied.
 
var myClass = new MyClass();
 
myClass.init();

API

---

Useify(object)

Add Useify to an object

object.use([params...], [fn])

Adds a middleware function to the queue. A dynamic amount of params can be passed from the previous middleware function. The callback must be the last paramater. use is chainable.

object.middleware([params...], [fn])

Runs the queue of middleware functions in the order they were added. A dynamic amount of params can be passed from the previous middleware function. The callback must be the last paramater.