reorg

Type checking and polymorphism via fallbacks.

Installation

$ npm install reorg

Examples

var fn = reorg(function(str, obj, cb) {
    cb(str, JSON.stringify(obj));
}, "string", "object");

var next = function(a, b) {
  console.log("A:", a, "B:", b);
}

fn(next);
// => A:  B: {}

fn("Hello", next);
// => "A: Hello B: {}"

fn({ key : "val"}, next);
// => A: B: {"key":"val"}

fn("Hello", {"key": "val" }, next);
// => A: Hello B: {"key":"val"}

var anotherFn = reorg(function(requiredString, optionalCallback) {
  optionalCallback(requiredString);
}, "string!", ["function", function() {}]);

anotherFn();
// => Error: Expected argument undefined to be of type string

anotherFn("Hello");
// => executes, disappearing into space

API

reorg ⇒ function
.args(argv, constraints, [truncate]) => Array
.checkArg(arg, constraint) ⇒ Object
.isType(arg, type) ⇒ Boolean
.defaultForType(type) ⇒ *

reorg ⇒ function

Adds type checking and polymorphism to a function.

Returns: function - Returns wrapped function.

Param	Type	Description
fn	function	The function to wrap.
...constraint	Contraint	Splat of constraints

Example

var newFn = reorg(function(requiredString, optionalCallback) {
    optionalCallback(requiredString);
  }, "string!", ["function", function(next) { next(); }]);

reorg.args(argv, constraints, [truncate])

Checks an array of arguments against an array of constraints, and optionally truncates the results.

Returns: Array - Array of reorganized arguments.

Param	Type	Default	Description
argv	Array		The arguments array to check.
constraints	Array		An of corresponding constraints.
[truncate]	Boolean	false	If true, truncates results at longer of argv/constraints.

reorg.checkArg(arg, constraint) ⇒ Object

Checks single argument against a constraint. Returns object containing fallback value if pass fails.

The following are valid constraints:{

• "string"
• "string!" (indicates required)
• ["string", "Fallback string"]
• ["string!", "Fallback string"]
• [testFn, fallbackValue]
• [["string", testFn1, testFn2], fallbackValue]}

Returns: Object - Returns {pass, fallback}.

Param	Type	Description
arg	*	The argument to check.
constraint	Constraint	The constraint to check against.

Example

reorg.checkArg(123, "string");
  // => { pass : false, fallback : "" }

reorg.isType(arg, type) ⇒ Boolean

Checks if an argument is of a type. type can include primitive types, "array", or a function

Returns: Boolean - Whether the check passes/fails.

Param	Type	Description
arg	*	The value to check.
type	String | function	A type or predicate to check against.

reorg.defaultForType(type) ⇒ *

Fallback values for types. Throws error if not string, object or array.

Kind: static method of reorg
Returns: * - A default value.

Param	Type	Description
type	String	Indicates which type for which we want fallback.

License

MIT