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