comb
comb Public
Defined index.js

Utilities for javascript, optimized for the server environment.

PropertyTypeDefault ValueDescription
bindAllpropertyhitchAll

Binds all methods or a specified array of function to the scope of the object

definepropertydefine

Defines a new class to be used

Class methods

  • as(module | object, name): exports the object to module or the object with the name
  • mixin(mixin) : mixes in an object

Instance methods
  • _super(argumnents, [?newargs]): calls the super of the current method

Instance properties
  • _static: use to reference class properties and methods

singletonpropertysingleton

Defines a singleton instance of a Class. See define

applyFirst Static Function Public

Defined base/functions.js

Binds a method to the scope of the first argument.

This is useful if you have async actions and you just want to run a method or retrieve a property on the object.

  1.  var arr = [], push = comb.applyFirst("push"), length = comb.applyFirst("length");
  2.  push(arr, 1, 2,3,4);
  3.  console.log(length(arr)); //4
  4.  console.log(arr); //1,2,3,4

Arguments Returns Source 
  1. function (method,args){
  2.    args = Array.prototype.slice.call(arguments).slice(1);
  3.    if (!isString(method) && !isFunction(method)) {
  4.        throw new Error(method + " must be the name of a property or function to execute");
  5.    }
  6.    if (isString(method)) {
  7.        return function () {
  8.            var scopeArgs = Array.prototype.slice.call(arguments), scope = scopeArgs.shift();
  9.            var func = scope[method];
  10.            if (isFunction(func)) {
  11.                scopeArgs = args.concat(scopeArgs);
  12.                return spreadArgs(func, scopeArgs, scope);
  13.            } else {
  14.                return func;
  15.            }
  16.        };
  17.    } else {
  18.        return function () {
  19.            var scopeArgs = Array.prototype.slice.call(arguments), scope = scopeArgs.shift();
  20.            scopeArgs = args.concat(scopeArgs);
  21.            return spreadArgs(method, scopeArgs, scope);
  22.        };
  23.    }
  24. }
  25.

argsToArray Static Function Public

Defined base/misc.js

Converts an arguments object to an array

Example 
  1. function test(){
  2.     return comb.argsToArray(arguments);
  3. }
  4.  
  5. function testSlice(){
  6.     return comb.argsToArray(arguments, 3);
  7. }
  8.  
  9. console.log(test(1,2,3)); //[1,2,3]
  10. console.log(test(1,2,3,4,5,6)); //[4,5,6]
  11.
Arguments Returns Source 
  1. function (args,slice){
  2.    slice = slice || 0;
  3.    return arraySlice.call(args, slice);
  4. }
  5.

bind Static Function Public

Defined base/functions.js

Arguments Returns Source 
  1. hitch
  2.

bindIgnore Static Function Public

Defined base/functions.js

Arguments Returns Source 
  1. hitchIgnore
  2.

broadcast Static Function Public

Defined base/broadcast.js

Broadcasts an event to all listeners NOTE : the function takes a variable number of arguments i.e. all arguments after the topic will be passed to the listeners

Example 
  1. comb.broadcast("hello", "hello world");
  2. //the args "hello" and "world" will be passed to any listener of the topic
  3. //"hello"
  4. comb.broadcast("hello", "hello", "world");
  5.
Arguments Source 
  1. function (){
  2.    var args = Array.prototype.slice.call(arguments);
  3.    var topic = args.splice(0, 1)[0];
  4.    if (topic) {
  5.        var list = listeners[topic];
  6.        if (list) {
  7.            for (var i = list.length - 1; i >= 0; i--) {
  8.                var han = list[i], cb = han.cb;
  9.                if (cb) {
  10.                    cb.apply(this, args);
  11.                }
  12.            }
  13.        }
  14.    }
  15.        
  16. }
  17.

camelize Static Function Public

Defined base/inflections.js

Converts a string to camelcase

Example 
  1. comb.camelize('hello_world') => helloWorld
  2.  comb.camelize('column_name') => columnName
  3.  comb.camelize('columnName') => columnName
  4.  comb.camelize(null) => null
  5.  comb.camelize() => undefined
  6.
Arguments Returns Source 
  1. function (str){
  2.    var ret = str;
  3.    if (!misc.isUndefinedOrNull(str)) {
  4.        ret = str.replace(CAMELIZE_CONVERT_REGEXP, function (a, b) {
  5.            return b.toUpperCase();
  6.        });
  7.    }
  8.    return ret;
  9. }
  10.

chain Static Function Public

Defined promise.js

Works just like comb.Promise#chain method, allowing you to propogate results from one funciton to another. This is different than comb.serial in that it propogates results from one promise to the next, where comb.serial does not.

Example 
  1. function asyncAction(add, timeout) {
  2.      return function (num) {
  3.          num = num || 0;
  4.          var ret = new comb.Promise();
  5.          setTimeout(function () {
  6.               ret.callback(num + add);
  7.          }, timeout);
  8.          return ret;
  9.      }
  10. }
  11.  
  12. comb.chain([
  13.      asyncAction(1, 100),
  14.      asyncAction(2, 100),
  15.      asyncAction(3, 100),
  16.      asyncAction(4, 100),
  17.      asyncAction(5, 100),
  18. ]).then(function(results){
  19.      console.log(results); //15
  20. });
  21.
Arguments Returns Source 
  1. function (list){
  2.    if (base.isArray(list)) {
  3.        return callNext(list, [], true);
  4.    } else {
  5.        throw new Error("When calling comb.serial the first argument must be an array");
  6.    }
  7. }
  8.

classify Static Function Public

Defined base/inflections.js

Singularizes and camelizes the string. Also strips out all characters preceding and including a period (".").

Example 
  1. comb.classify('egg_and_hams') => "eggAndHam"
  2.   comb.classify('post') => "post"
  3.   comb.classify('schema.post') => "post"
  4.
Arguments Returns Source 
  1. function (str){
  2.    var ret = str;
  3.    if (!misc.isUndefinedOrNull(str)) {
  4.        ret = comb.camelize(comb.singularize(str.replace(/.*\./g, '')));
  5.    }
  6.    return ret;
  7. }
  8.

connect Static Function Public

Defined base/broadcast.js

Function to listen when other functions are called

Example 
  1. comb.connect(obj, "event", myfunc);
  2.  comb.connect(obj, "event", "log", console);
  3.
Arguments Returns Source 
  1. function (obj,method,cb,scope){
  2.    var index,
  3.        listeners;
  4.    if (typeof method !== "string") {
  5.        throw new Error("When calling connect the method must be string");
  6.    }
  7.    if (!func.isFunction(cb)) {
  8.        throw new Error("When calling connect callback must be a string");
  9.    }
  10.    scope = obj || global;
  11.    if (typeof scope[method] === "function") {
  12.        listeners = scope[method].__listeners;
  13.        if (!listeners) {
  14.            var newMethod = wrapper();
  15.            newMethod.func = obj[method];
  16.            listeners = (newMethod.__listeners = []);
  17.            scope[method] = newMethod;
  18.        }
  19.        index = listeners.push(cb);
  20.    } else {
  21.        throw new Error("unknow method " + method + " in object " + obj);
  22.    }
  23.    return [obj, method, index];
  24.        
  25. }
  26.

curry Static Function Public

Defined base/functions.js

Curries a function

Example 
  1. var curried = comb.curry(4, function(a,b,c,d){
  2.     return [a,b,c,d].join(",");
  3. }
  4.  curried("a");
  5.  curried("b");
  6.  curried("c");
  7.  curried("d") => "a,b,c,d"
  8.  
  9.  //OR
  10.  
  11.  curried("a")("b")("c")("d") => "a,b,c,d"
  12.
Arguments Returns Source 
  1. function (depth,cb,scope){
  2.    var f;
  3.    if (scope) {
  4.        f = hitch(scope, cb);
  5.    } else {
  6.        f = cb;
  7.    }
  8.    if (depth) {
  9.        var len = depth - 1;
  10.        for (var i = len; i >= 0; i--) {
  11.            f = curryFunc(f, i === len);
  12.        }
  13.    }
  14.    return f;
  15. }
  16.

daysAgo Static Function Public

Defined base/date/index.js

Subtracts the specified day/s from the current date.

Arguments Returns Source 
  1. function (val){
  2.    return date.add(new Date(), "days", -val);
  3. }
  4.

daysFromNow Static Function Public

Defined base/date/index.js

Adds the specified day/s to the current date.

Arguments Returns Source 
  1. function (val){
  2.    return date.add(new Date(), "days", val);
  3. }
  4.

deepEqual Static Function Public

Defined base/object.js

Determines if two things are deep equal.

Example 
  1. comb.deepEqual({a : 1, b : 2}, {a : 1, b : 2}) => true
  2. comb.deepEqual({a : 1}, {a : 1, b : 2}) => false
  3.
Arguments Returns Source 
  1. function (o1,o2){
  2.    return _deepEqual(o1, o2);
  3. }
  4.

deepMerge Static Function Public

Defined base/object.js

Merges objects together only overriding properties that are different. NOTE: this function takes a variable number of objects to merge

Example 
  1. var myObj = {my : {cool : {property1 : 1, property2 : 2}}};
  2. comb.deepMerge(myObj, {my : {cool : {property3 : 3}}});
  3.  
  4. myObj.my.cool.property1 => 1
  5. myObj.my.cool.property2 => 2
  6. myObj.my.cool.property3 => 3
  7.
Arguments Returns Source 
  1. function (obj,props){
  2.    if (!obj) {
  3.        obj = {};
  4.    }
  5.    for (var i = 1, l = arguments.length; i < l; i++) {
  6.        deepMerge(obj, arguments[i]);
  7.    }
  8.    return obj; // Object
  9. }
  10.

disconnect Static Function Public

Defined base/broadcast.js

Disconnects a listener to a function

Arguments Source 
  1. function (handle){
  2.    if (handle && handle.length === 3) {
  3.        var obj = handle[0], method = handle[1], cb = handle[2];
  4.        if (typeof method !== "string") {
  5.            throw "comb.disconnect : When calling disconnect the method must be string";
  6.        }
  7.        var scope = obj || global, ls;
  8.        if (typeof scope[method] === "function") {
  9.            ls = scope[method].__listeners;
  10.            if (ls && cb-- > 0) {
  11.                //we dont want to splice it because our indexing will get off
  12.                ls[cb] = null;
  13.            }
  14.        } else {
  15.            throw new Error("unknown method " + method + " in object " + obj);
  16.        }
  17.    } else {
  18.        throw new Error("comb.disconnect : invalid handle");
  19.    }
  20.        
  21. }
  22.

extend Static Function Public

Defined base/object.js

Extends the prototype of an object if it exists otherwise it extends the object.

Example 
  1. var MyObj = function(){};
  2.  MyObj.prototype.test = true;
  3.  comb.extend(MyObj, {test2 : false, test3 : "hello", test4 : "world"});
  4.  
  5.  var myObj = new MyObj();
  6.  
  7.  myObj.test => true
  8.  myObj.test2 => false
  9.  myObj.test3 => "hello"
  10.  myObj.test4 => "world"
  11.  
  12.  var myObj2 = {};
  13.  myObj2.test = true;
  14.  comb.extend(myObj2, {test2 : false, test3 : "hello", test4 : "world"});
  15.  
  16.  myObj2.test => true
  17.  myObj2.test2 => false
  18.  myObj2.test3 => "hello"
  19.  myObj2.test4 => "world"
  20.
Arguments Returns Source 
  1. function (parent,ext){
  2.    var proto = parent.prototype || parent;
  3.    merge(proto, ext);
  4.    return parent;
  5. }
  6.

hitch Static Function Public

Defined base/functions.js

Binds a method to a particular scope

Arguments Returns Source 
  1. function (scope,method,args){
  2.    args = Array.prototype.slice.call(arguments).slice(2);
  3.    if ((isString(method) && !(method in scope))) {
  4.        throw new Error(method + " property not defined in scope");
  5.    } else if (!isString(method) && !isFunction(method)) {
  6.        throw new Error(method + " is not a function");
  7.    }
  8.    if (isString(method)) {
  9.        return function () {
  10.            var func = scope[method];
  11.            if (isFunction(func)) {
  12.                var scopeArgs = args.concat(Array.prototype.slice.call(arguments));
  13.                return spreadArgs(func, scopeArgs, scope);
  14.            } else {
  15.                return func;
  16.            }
  17.        };
  18.    } else {
  19.        return function () {
  20.            var scopeArgs = args.concat(Array.prototype.slice.call(arguments));
  21.            return spreadArgs(method, scopeArgs, scope);
  22.        };
  23.    }
  24. }
  25.

hitchAll Static Function Public

Defined base/functions.js

Binds all methods or a specified array of function to the scope of the object

Example 
  1. var f = {
  2.     a: function(){
  3.         return "a";
  4.     },
  5.     b: function(){
  6.         return "b";
  7.     }
  8. }
  9.  
  10. comb.hitchAll(f, "a", "b");
  11.  
  12. //or
  13.  
  14. comb.hitchAll(f);
  15.
Arguments Returns Source 
  1. function (scope){
  2.    var funcs = Array.prototype.slice.call(arguments, 1);
  3.    if (!isObject(scope) && !isFunction(scope)) {
  4.        throw new TypeError("scope must be an object");
  5.    }
  6.    if (funcs.length === 1 && isArray(funcs[0])) {
  7.        funcs = funcs[0];
  8.    }
  9.    if (!funcs.length) {
  10.        funcs = [];
  11.        for (var k in scope) {
  12.            if (scope.hasOwnProperty(k) && isFunction(scope[k])) {
  13.                funcs.push(k);
  14.            }
  15.        }
  16.    }
  17.    for (var i = 0, l = funcs.length; i < l; i++) {
  18.        scope[funcs[i]] = hitch(scope, scope[funcs[i]]);
  19.    }
  20.    return scope;
  21. }
  22.

hitchIgnore Static Function Public

Defined base/functions.js

Binds a method to a particular scope ignoring any new arguments passed into the function. This is useful if you want to force particular arguments and ignore any new ones

Arguments Returns Source 
  1. function (scope,method,args){
  2.    args = Array.prototype.slice.call(arguments).slice(2);
  3.    if ((isString(method) && !(method in scope))) {
  4.        throw new Error(method + " property not defined in scope");
  5.    } else if (!isString(method) && !isFunction(method)) {
  6.        throw new Error(method + " is not a function");
  7.    }
  8.    if (isString(method)) {
  9.        return function () {
  10.            var func = scope[method];
  11.            if (isFunction(func)) {
  12.                return spreadArgs(func, args, scope);
  13.            } else {
  14.                return func;
  15.            }
  16.        };
  17.    } else {
  18.        return function () {
  19.            return spreadArgs(method, args, scope);
  20.        };
  21.    }
  22. }
  23.

hoursAgo Static Function Public

Defined base/date/index.js

Subtracts the specified hour/s from the current date.

Arguments Returns Source 
  1. function (val){
  2.    return date.add(new Date(), "hours", -val);
  3. }
  4.

hoursFromNow Static Function Public

Defined base/date/index.js

Adds the specified hour/s to the current date.

Arguments Returns Source 
  1. function (val){
  2.    return date.add(new Date(), "hours", val);
  3. }
  4.

isArguments Static Function Public

Defined base/misc.js

Determines if obj is an Arguments object;

Arguments Returns Source 
  1. function (object){
  2.    return !isUndefinedOrNull(object) && Object.prototype.toString.call(object) === '[object Arguments]';
  3. }
  4.

isBoolean Static Function Public

Defined base/misc.js

Determines if obj is a boolean

Arguments Returns Source 
  1. function (obj){
  2.    var undef, type = typeof obj;
  3.    return obj !== undef && type === "boolean" || type === "Boolean";
  4. }
  5.

isDate Static Function Public

Defined base/date/index.js

Determines if obj is a Date

Arguments Returns Source 
  1. function (obj){
  2.    var undef;
  3.    return (obj !== undef && typeof obj === "object" && obj instanceof Date);
  4. }
  5.

isDefined Static Function Public

Defined base/misc.js

Determins if the obj is not undefined

Arguments Returns Source 
  1. function (obj){
  2.    return !isUndefined(obj);
  3. }
  4.

isEmpty Static Function Public

Defined base/object.js

Determines if an object is empty

Example 
  1. comb.isEmpty({}) => true
  2. comb.isEmpty({a : 1}) => false
  3.
Arguments Returns Source 
  1. function (object){
  2.    if (comb.isObject(object)) {
  3.        for (var i in object) {
  4.            if (object.hasOwnProperty(i)) {
  5.                return false;
  6.            }
  7.        }
  8.    }
  9.    return true;
  10. }
  11.

isFunction Static Function Public

Defined base/functions.js

Determines if something is a function

Arguments Returns Source 
  1. function (obj){
  2.    return typeof obj === "function";
  3. }
  4.

isHash Static Function Public

Defined base/object.js

Determines if an object is just a hash and not a qualified Object such as Number

Example 
  1. comb.isHash({}) => true
  2.    comb.isHash({1 : 2, a : "b"}) => true
  3.    comb.isHash(new Date()) => false
  4.    comb.isHash(new String()) => false
  5.    comb.isHash(new Number()) => false
  6.    comb.isHash(new Boolean()) => false
  7.    comb.isHash() => false
  8.    comb.isHash("") => false
  9.    comb.isHash(1) => false
  10.    comb.isHash(false) => false
  11.    comb.isHash(true) => false
  12.
Arguments Returns Source 
  1. function (obj){
  2.    var ret = comb.isObject(obj);
  3.    return ret && obj.constructor === Object;
  4. }
  5.

isInstanceOf Static Function Public

Defined base/misc.js

Determines if obj is an instance of a particular class

Arguments Returns Source 
  1. function (obj,clazz){
  2.    return argsToArray(arguments, 1).some(function (c) {
  3.        return isInstance(obj, c);
  4.    });
  5. }
  6.

isNull Static Function Public

Defined base/misc.js

Determines if obj is null

Arguments Returns Source 
  1. function (obj){
  2.    var undef;
  3.    return obj !== undef && obj == null;
  4. }
  5.

isNumber Static Function Public

Defined base/number.js

Determines if obj is a number

Arguments Returns Source 
  1. function (obj){
  2.    var undef;
  3.    return obj !== undef && obj != null && (typeof obj === "number" || obj instanceof Number);
  4. }
  5.

isObject Static Function Public

Defined base/object.js

Determines if obj is an object

Arguments Returns Source 
  1. function (obj){
  2.    var undef;
  3.    return obj !== null && obj !== undef && typeof obj === "object";
  4. }
  5.

isPromiseLike Static Function Public

Defined promise.js

Tests if an object is like a promise (i.e. it contains then, addCallback, addErrback)

Arguments Source 
  1. function (obj){
  2.    return isObject(obj, Promise) && typeof obj.then === "function";
  3. }
  4.

isRegExp Static Function Public

Defined base/regexp.js

Tests if something is a regular expression.

Example 
  1. comb.isRegExp(/hello/); //true
  2. comb.isRegExp("hello"); //false
  3.
Arguments Returns Source 
  1. function (obj){
  2.    var undef;
  3.    return obj !== undef && obj != null && (obj instanceof RegExp);
  4. }
  5.

isString Static Function Public

Defined base/string.js

Tests if something is a string.

Example 
  1. comb.isString("true") //true
  2. comb.isString(true) //false
  3.
Arguments Returns Source 
  1. function (obj){
  2.    return toStr.call(obj) === '[object String]';
  3. }
  4.

isUndefined Static Function Public

Defined base/misc.js

Determines if obj is undefined

Arguments Returns Source 
  1. function (obj){
  2.    var undef;
  3.    return obj !== null && obj === undef;
  4. }
  5.

isUndefinedOrNull Static Function Public

Defined base/misc.js

Determines if obj is undefined or null

Arguments Returns Source 
  1. function (obj){
  2.    return isUndefined(obj) || isNull(obj);
  3. }
  4.

listen Static Function Public

Defined base/broadcast.js

Listen for the broadcast of certain events

Example 
  1. comb.listen("hello", function(arg1, arg2){
  2.     console.log(arg1);
  3.     console.log(arg2);
  4.  });
  5.
Arguments Returns Source 
  1. function (topic,callback){
  2.    if (!func.isFunction(callback)) {
  3.        throw new Error("callback must be a function");
  4.    }
  5.    var handle = {
  6.        topic: topic,
  7.        cb: callback,
  8.        pos: null
  9.    };
  10.    var list = listeners[topic];
  11.    if (!list) {
  12.        list = (listeners[topic] = []);
  13.    }
  14.    list.push(handle);
  15.    handle.pos = list.length - 1;
  16.    return handle;
  17.        
  18. }
  19.

listenForExit Static Function Public

Defined base/misc.js

Adds listeners to process.exit without having to change setMaxListeners useful if you are writing a library and do not want to change core setting.

Arguments Source 
  1. function (cb){
  2.    setupListener();
  3.    listeners.push(cb);
  4.        
  5. }
  6.

merge Static Function Public

Defined base/object.js

Merges objects together NOTE: this function takes a variable number of objects to merge

Example 
  1. var myObj = {};
  2. comb.merge(myObj, {test : true});
  3.  
  4. myObj.test => true
  5.  
  6. comb.merge(myObj, {test : false}, {test2 : false}, {test3 : "hello", test4 : "world"});
  7. myObj.test => false
  8. myObj.test2 => false
  9. myObj.test3 => "hello"
  10. myObj.test4 => "world"
  11.
Arguments Returns Source 
  1. function (obj,props){
  2.    if (!obj) {
  3.        obj = {};
  4.    }
  5.    for (var i = 1, l = arguments.length; i < l; i++) {
  6.        merge(obj, arguments[i]);
  7.    }
  8.    return obj; // Object
  9. }
  10.

minutesAgo Static Function Public

Defined base/date/index.js

Subtracts the specified minute/s from the current date.

Arguments Returns Source 
  1. function (val){
  2.    return date.add(new Date(), "minutes", -val);
  3. }
  4.

minutesFromNow Static Function Public

Defined base/date/index.js

Adds the specified minute/s to the current date.

Arguments Returns Source 
  1. function (val){
  2.    return date.add(new Date(), "minutes", val);
  3. }
  4.

monthsAgo Static Function Public

Defined base/date/index.js

Subtracts the specified month/s from the current date.

Arguments Returns Source 
  1. function (val){
  2.    return date.add(new Date(), "months", -val);
  3. }
  4.

monthsFromNow Static Function Public

Defined base/date/index.js

Adds the specified month/s to the current date.

Example 
  1. //assuming that current month is february
  2. comb.yearsFromNow(2); //yyyy-04-dd hh:MM:ss
  3.
Arguments Returns Source 
  1. function (val){
  2.    return date.add(new Date(), "months", val);
  3. }
  4.

partial Static Function Public

Defined base/functions.js

Allows the passing of additional arguments to a function when it is called especially useful for callbacks that you want to provide additional parameters to

Arguments Returns Source 
  1. function (method,args){
  2.    args = Array.prototype.slice.call(arguments).slice(1);
  3.    if (!isString(method) && !isFunction(method)) {
  4.        throw new Error(method + " must be the name of a property or function to execute");
  5.    }
  6.    if (isString(method)) {
  7.        return function () {
  8.            var func = this[method];
  9.            if (isFunction(func)) {
  10.                var scopeArgs = args.concat(Array.prototype.slice.call(arguments));
  11.                return spreadArgs(func, scopeArgs, this);
  12.            } else {
  13.                return func;
  14.            }
  15.        };
  16.    } else {
  17.        return function () {
  18.            var scopeArgs = args.concat(Array.prototype.slice.call(arguments));
  19.            return spreadArgs(method, scopeArgs, this);
  20.        };
  21.    }
  22. }
  23.

pluralize Static Function Public

Defined base/inflections.js

Returns the plural form of the word in the string.

Example 
  1. comb.pluralize("post") => "posts"
  2.  comb.pluralize("octopus") => "octopi"
  3.  comb.pluralize("sheep") => "sheep"
  4.  comb.pluralize("words") => "words"
  5.  comb.pluralize("the blue mailman") => "the blue mailmen"
  6.  comb.pluralize("CamelOctopus") => "CamelOctopi"
  7.
Arguments Returns Source 
  1. function (str){
  2.    var ret = str;
  3.    if (!misc.isUndefinedOrNull(str)) {
  4.        if (UNCOUNTABLES.indexOf(str) === -1) {
  5.            for (var i in PLURALS) {
  6.                var s = PLURALS[i], rule = s[0], replacement = s[1];
  7.                if ((ret = ret.replace(rule, replacement)) !== str) {
  8.                    break;
  9.                }
  10.            }
  11.        }
  12.    }
  13.    return ret;
  14. }
  15.

promisfyStream Static Function Public

Defined promise.js

Wraps a stream in a promise waiting for either the "end" or "error" event to be triggered.

  1. comb.promisfyStream(fs.createdReadStream("my.file")).chain(function(){
  2.      console.log("done reading!");
  3. });

Arguments Returns Source 
  1. function (stream){
  2.    var ret = new Promise(), called;
  3.    function errorHandler() {
  4.        if (!called) {
  5.            called = true;
  6.            spreadArgs(ret.errback, arguments, ret);
  7.            stream.removeListener("error", endHandler);
  8.            stream.removeListener("end", endHandler);
  9.            stream = ret = null;
  10.        }
  11.    }
  12.    function endHandler() {
  13.        if (!called) {
  14.            called = true;
  15.            spreadArgs(ret.callback, arguments, ret);
  16.            stream.removeListener("error", endHandler);
  17.            stream.removeListener("end", endHandler);
  18.            stream = ret = null;
  19.        }
  20.    }
  21.    stream.on("error", errorHandler).on("end", endHandler);
  22.    return ret.promise();
  23. }
  24.

rejected Static Function Public

Defined promise.js

Creates a new comb.Promise that is rejected with the given value.

  1. comb.resolved(new Error("error!")).chain(null, function(err){
  2.      console.error(err.stack);
  3. });

If you give it a promise it will wait for the promise to resolve or error but with reject either way.

  1. comb.resolved(new comb.Promise().callback(1)).chain(null, function(err){
  2.      //err === 1
  3. });

Arguments Returns Source 
  1. function (val){
  2.    var ret = new Promise();
  3.    when(val).chain(ret.errback, ret.errback);
  4.    return ret.promise();
  5. }
  6.

resolved Static Function Public

Defined promise.js

Creates a new comb.Promise that is resolved with the given value.

  1. comb.resolved(1).chain(function(val){
  2.      //val === 1
  3. });

If you give it a promise it will wait for the promise to resolve or error.

  1. comb.resolved(new comb.Promise().callback(1)).chain(function(val){
  2.      //val === 1
  3. });

Arguments Returns Source 
  1. function (val){
  2.    var ret = new Promise();
  3.    when(val).chain(ret.callback, ret.errback);
  4.    return ret.promise();
  5. }
  6.

secondsAgo Static Function Public

Defined base/date/index.js

Subtracts the specified second/s from the current date.

Arguments Returns Source 
  1. function (val){
  2.    return date.add(new Date(), "seconds", -val);
  3. }
  4.

secondsFromNow Static Function Public

Defined base/date/index.js

Adds the specified second/s to the current date.

Arguments Returns Source 
  1. function (val){
  2.    return date.add(new Date(), "seconds", val);
  3. }
  4.

serial Static Function Public

Defined promise.js

Executes a list of items in a serial manner. If the list contains promises then each promise will be executed in a serial manner, if the list contains non async items then the next item in the list is called.

Example 
  1. var asyncAction = function(item, timeout){
  2.    var ret = new comb.Promise();
  3.    setTimeout(comb.hitchIgnore(ret, "callback", item), timeout);
  4.    return ret.promise();
  5. };
  6.  
  7. comb.serial([
  8.     comb.partial(asyncAction, 1, 1000),
  9.     comb.partial(asyncAction, 2, 900),
  10.     comb.partial(asyncAction, 3, 800),
  11.     comb.partial(asyncAction, 4, 700),
  12.     comb.partial(asyncAction, 5, 600),
  13.     comb.partial(asyncAction, 6, 500)
  14. ]).then(function(results){
  15.     console.log(results); // [1,2,3,4,5,6];
  16. });
  17.
Arguments Source 
  1. function (list,callback,errback){
  2.    if (base.isArray(list)) {
  3.        return callNext(list, [], false);
  4.    } else {
  5.        throw new Error("When calling comb.serial the first argument must be an array");
  6.    }
  7. }
  8.

singularize Static Function Public

Defined base/inflections.js

The reverse of pluralize, returns the singular form of a word in a string.

Example 
  1. comb.singularize("posts") => "post"
  2.   comb.singularize("octopi")=> "octopus"
  3.   comb.singularize("sheep") => "sheep"
  4.   comb.singularize("word") => "word"
  5.   comb.singularize("the blue mailmen") => "the blue mailman"
  6.   comb.singularize("CamelOctopi") => "CamelOctopus"
  7.
Arguments Returns Source 
  1. function (str){
  2.    var ret = str;
  3.    if (!misc.isUndefinedOrNull(str)) {
  4.        if (UNCOUNTABLES.indexOf(str) === -1) {
  5.            for (var i in SINGULARS) {
  6.                var s = SINGULARS[i], rule = s[0], replacement = s[1];
  7.                if ((ret = ret.replace(rule, replacement)) !== str) {
  8.                    break;
  9.                }
  10.            }
  11.        }
  12.    }
  13.    return ret;
  14. }
  15.

unListen Static Function Public

Defined base/broadcast.js

Disconnects a listener

Arguments Source 
  1. function (handle){
  2.    if (handle) {
  3.        var topic = handle.topic, list = listeners[topic];
  4.        if (list) {
  5.            for (var i = list.length - 1; i >= 0; i--) {
  6.                if (list[i] === handle) {
  7.                    list.splice(i, 1);
  8.                }
  9.            }
  10.            if (!list.length) {
  11.                delete listeners[topic];
  12.            }
  13.        }
  14.    }
  15.        
  16. }
  17.

underscore Static Function Public

Defined base/inflections.js

The reverse of camelize. Makes an underscored form from the expression in the string.

Example 
  1. comb.underscore('helloWorld') => hello_world
  2.  comb.underscore('column_name') => column_name
  3.  comb.underscore('columnName') => column_name
  4.  comb.underscore(null) => null
  5.  comb.underscore() => undefined
  6.
Arguments Returns Source 
  1. function (str){
  2.    var ret = str;
  3.    if (!misc.isUndefinedOrNull(str)) {
  4.        ret = str.replace(UNDERSCORE_CONVERT_REGEXP1, UNDERSCORE_CONVERT_REPLACE)
  5.            .replace(UNDERSCORE_CONVERT_REGEXP2, UNDERSCORE_CONVERT_REPLACE)
  6.            .replace(DASH, UNDERSCORE).toLowerCase();
  7.    }
  8.    return ret;
  9. }
  10.

wait Static Function Public

Defined promise.js

Ensures that a promise is resolved before a the function can be run.

For example suppose you have to ensure that you are connected to a database before you execute a function.

  1. var findUser = comb.wait(connect(), function findUser(id){
  2.      //this wont execute until we are connected
  3.      return User.findById(id);
  4. });
  6.  comb.when(findUser(1), findUser(2)).then(function(users){
  7.      var user1 = users[0], user2 = users[1];
  8.  });

Arguments Returns Source 
  1. function (args,fn){
  2.    var resolved = false;
  3.    args = argsToArray(arguments);
  4.    fn = args.pop();
  5.    var p = when(args);
  6.    return function waiter() {
  7.        if (!resolved) {
  8.            var args = arguments;
  9.            return p.chain(function () {
  10.                resolved = true;
  11.                p = null;
  12.                return fn.apply(this, args);
  13.            }.bind(this));
  14.        } else {
  15.            return when(fn.apply(this, arguments));
  16.        }
  17.    };
  18. }
  19.

weekDaysAgo Static Function Public

Defined base/date/index.js

Subtracts the specified weekday/s from the current date.

Arguments Returns Source 
  1. function (val){
  2.    return date.add(new Date(), "weekdays", -val);
  3. }
  4.

weekDaysFromNow Static Function Public

Defined base/date/index.js

Adds the specified weekday/s to the current date.

Arguments Returns Source 
  1. function (val){
  2.    return date.add(new Date(), "weekdays", val);
  3. }
  4.

when Static Function Public

Defined promise.js

Waits for promise and non promise values to resolve and fires callback or errback appropriately. If you pass in an array of promises then it will wait for all promises in the list to resolve.

Example 
  1. var a = "hello";
  2.  var b = new comb.Promise().callback(world);
  3.  comb.when(a, b) => called back with ["hello", "world"];
  4.
Arguments Returns Source 
  1. function (args,cb,eb){
  2.    var p;
  3.    args = argsToArray(arguments);
  4.    eb = base.isFunction(args[args.length - 1]) ? args.pop() : null;
  5.    cb = base.isFunction(args[args.length - 1]) ? args.pop() : null;
  6.    if (eb && !cb) {
  7.        cb = eb;
  8.        eb = null;
  9.    }
  10.    if (!args.length) {
  11.        p = new Promise().callback(args);
  12.    } else if (args.length === 1) {
  13.        args = args.pop();
  14.        if (isPromiseLike(args)) {
  15.            p = args;
  16.        } else if (isArray(args) && array.every(args, isPromiseLike)) {
  17.            p = new PromiseList(args, true);
  18.        } else {
  19.            p = new Promise().callback(args);
  20.        }
  21.    } else {
  22.        p = new PromiseList(args.map(function (a) {
  23.            return isPromiseLike(a) ? a : new Promise().callback(a);
  24.        }), true);
  25.    }
  26.    if (cb) {
  27.        p.addCallback(cb);
  28.    }
  29.    if (eb) {
  30.        p.addErrback(eb);
  31.    }
  32.    return p.promise();
  33. }
  34.

wrap Static Function Public

Defined promise.js

Wraps traditional node style functions with a promise.

Example 
  1. var fs = require("fs");
  2. var readFile = comb.wrap(fs.readFile, fs);
  3. readFile(__dirname + "/test.json").then(
  4.      function(buffer){
  5.          console.log(contents);
  6.      },
  7.      function(err){
  8.  
  9.      }  console.error(err);
  10. );
  11.
Arguments Returns Source 
  1. function (fn,scope){
  2.    return function () {
  3.        var ret = new Promise();
  4.        var args = argsToArray(arguments);
  5.        args.push(ret.resolve.bind(ret));
  6.        fn.apply(scope || this, args);
  7.        return ret.promise();
  8.    };
  9. }
  10.

yearsAgo Static Function Public

Defined base/date/index.js

Subtracts the specified year/s from the current date.

Arguments Returns Source 
  1. function (val){
  2.    return date.add(new Date(), "years", -val);
  3. }
  4.

yearsFromNow Static Function Public

Defined base/date/index.js

Adds the specified year/s to the current date.

Example 
  1. //assuming that current year is 2012
  2. comb.yearsFromNow(1); //2013-mm-dd hh:MM:ss
  3.
Arguments Returns Source 
  1. function (val){
  2.    return date.add(new Date(), "years", val);
  3. }
  4.

License

MIT https://github.com/C2FO/comb/raw/master/LICENSE

Meta