bauer-factory v2.0.6

node-bauer-factory

General utilities for nodejs.

Installation

npm install bauer-factory

Usage

var factory = require("bauer-factory");

.type

Returned value can be string, number, boolean, date, regexp, error, array, object, arguments, null, undefined or function.

// returns type of given argument
var type = factory.type(arg);

.isNull

factory.isNull(arg)
// same as
factory.type(arg) === "null"

.isDefined

factory.isDefined(arg)
// same as
factory.type(arg) !== "undefined"

.isUndefined

factory.isUndefined(arg)
// same as
factory.type(arg) === "undefined"

.isDate

factory.isDate(arg)
// same as
factory.type(arg) === "date"

.isError

factory.isError(arg)
// same as
factory.type(arg) === "error"

.isBoolean

factory.isBoolean(arg)
// same as
factory.type(arg) === "boolean"

.isArray

factory.isArray(arg)
// same as
factory.type(arg) === "array"

.isNumber

factory.isNumber(arg)
// same as
factory.type(arg) === "number"

.isString

factory.isString(arg)
// same as
factory.type(arg) === "string"

.isObject

factory.isObject(arg)
// same as
factory.type(arg) === "object"

.isRegExp

factory.isRegExp(arg)
// same as
factory.type(arg) === "regexp"

.isFunction

factory.isFunction(arg)
// same as
factory.type(arg) === "function"

.isArguments

factory.isArguments(arg)
// same as
factory.type(arg) === "arguments"

.createMethod

Accepts an object containing types/lengths as keys and values as functions.

var func = factory.createMethod({
	0: function() {}, // executed if called with zero arguments
	s: function(s) {}, // executed if called with one string
	sf: function(s) {}, // executed if called with a string and a function
	_: function() {}, // executed if none of the above is matched
});

Letters are taken as the first character of the argument's type as returned by factory.type. Any combination can be used to route the function execution. This takes priority over argument's length routing.

var func = factory.createMethod({
	o: function() {}, // executed if called with object
	a: function(s) {}, // executed if called with array or arguments
	sffb: function(s,f0,f1,b) {}, // executed if called with a string, two functions and a boolean
});

Numbers are taken as the length of the arguments object. Nested rules are supported.

var func = factory.createMethod({
	5: { // executed if called with five arguments
		sssss: function() {}, // five strings
		assss: function() {}, // one array and four strings
	},
	1: function(arg) {}, // executed if called with one argument
});

Underscore holds the default code. If no rule is matched and there's no _ throws an ReferenceError.

var func = factory.createMethod({
	_: function() {},
});

Strings can be used as code. They are converted to functions internally with the defined arguments.

var func = factory.createMethod({
	s: "return this.get(s)", // the given string can be refered as 's'
	ss: "return this.both(s0,s1)", // if it's two strings, just add the index
	f: "this.on('ready',f)", // easy to define aliases
});

If the code does not use any external vars its possible to optimize the generated function by passing a second argument as true.

var optimized = factory.createMethod({
	s: "return this.get(s)",
	ss: "return this.both(s0,s1)",
	f: "this.on('ready',f)",
},true); // tell factory.method that this function does not use any external var

.createClass

Creates a class with given methods, constructor and inheritance.

var Bauer = factory.createClass({

	// requires 'events' and inherits EventEmitter from it
	// also accepts functions
	inherits: require("events").EventEmitter,

	// called when new Bauer() is executed
	// it can also be routed by factory.method if needed
	constructor: function() {
	},

	// methods are created by factory.method
	killTerrorists: {
	},

	tortureSuspects: {
	},

	doWhateverIsNecessary: function() {},

});

The created class can be instantiated and inherited just like any other class.

var jack = new Bauer();

jack.killTerrorists();

jack.tortureSuspects();

jack.doWhateverIsNecessary();

.createObject

Creates a class just like .class does and returns an instance of it.

// accepts same arguments as .createClass
var jack = factory.createObject({

	// requires 'events' and inherits EventEmitter from it
	// also accepts functions
	inherits: require("events").EventEmitter,

	// called when new Bauer() is executed
	// it can also be routed by factory.method if needed
	constructor: function() {
	},

	// methods are created by factory.method
	killTerrorists: {
		s: function() {},
		n: function() {},
	},

	tortureSuspects: {
		1: function() {},
		2: function() {},
	},

	doWhateverIsNecessary: function() {},

});