credible v0.2.2

credible

Credible is a library for validating objects in node.js or the browser. While it provides several validators out of the box, credible is very unopinionated; mostly, credible simply provides a framework for object validation.

Installation

Credible has one dependency: An A+ promise library, i.e. bluebird or when.js.

Node.js

$ npm install credible --save

Node takes care of the dependency automatically.

Browser

<script src="/bluebird.js"></script>
<script src="/credible.min.js"></script>

By default, Credible uses bluebird; to use a different implementation, set Credible.Promise to the correct library.

Usage

var rules = {
  name: {
    presence: true
  },
  email: {
    email: true
  }
}

var obj = {
  name: 'Noah Portes Chaikin',
  email: 'noah.porteschaikin@carrotcreative.com'
}

var credible = new Credible(rules)
  .run(obj)
  .catch(function (errors) {
    console.log(errors.toJSON());
  })

See examples.

API

Every method in a Credible instance returns the instance except credible.run(), which returns a promise.

new Credible(arguments..)

The main Credible constructor optionally accepts the same arguments as credible.rule() (see below).

credible.rule(arguments..)

Used to set new rules. credible.rule() is a variadic function; it accepts any of the following sets of arguments:

credible
  .rule(properties, validator, options)
  .rule(properties, { validator1: options, validator2: options })
  .rule(validator, options)

validator is either an available validator or a function. To use an available validator, simply pass the validator's name as a string or an object key:

credible
  .rule('name', 'presence', true)
  .rule('name', { length: { greaterThan: 5 } })
  .rule(['firstName', 'lastName'], { length: { greaterThan: 5 } })
  .rule({ name: { presence: true }, email: { email: { if: function (obj) { return obj.email; } } } })

On validation, a validator function is passed the object, the property key (if provided), and options. Validator functions can return promises for asynchronous validation. This is an example validator:

var emailValidator = function (object, property, options) {
  if ( /^[a-z0-9._%+\-]+@[a-z0-9.\-]+\.[a-z]{2,6}$/i.test(object[property])) {
    throw property + ' is an invalid e-mail address';
  }
}

Validators can be sent any number of settings in the options object; the following options are made available to every validator and are handled by the credible object:

credible.if([properties], fn)

Only run validator if fn (a function) returns true. fn is passed the object being validated. Optionally, passing properties will only execute the test on validators executed on the specified properties.

credible
  .if(function (object) {
    return object.foo == 'bar';
  });

credible
  .if('name', function (object) {
    return object.foo == 'bar';
  });

credible
  .if(['firstName', 'lastName'], function (object) {
    return object.foo == 'bar';
  });

credible.unless([property], fn)

Only run validator if fn (a function) returns false. fn is passed the object being validated. Optionally, passing properties will only execute the test on validators executed on the specified properties.

credible
  .unless(function (object) {
    return object.foo == 'bar';
  });

credible
  .unless('name', function (object) {
    return object.foo == 'bar';
  });

credible
  .unless(['firstName', 'lastName'], function (object) {
    return object.foo == 'bar';
  });

credible.invalid([property], fn)

Pass fn, a function, for handling a failed validation. fn is passed the object being validated. Optionally, passing properties will only execute the function for failed validations executed on the specified properties.

credible
  .invalid(function (object) {
    throw 'This object is invalid.';
  });

credible
  .invalid('name', function (object) {
    throw 'This name is invalid.';
  });

credible
  .invalid(['firstName', 'lastName'], function (object) {
    throw 'This name is invalid.';
  });

credible.run(object)

Run validations on object; returns a promise.

credible
  .run(obj)
  .then(function () {
    console.log('It\'s valid!');
  })
  .catch(function (errors) {
    console.log(errors.toJSON());
  })

Available Validators

alpha

Property must contain only letters.

alphaNumeric

Property must contain only letters and numbers.

alphaNumericDash

Property must contain only letters, numbers and dashes.

alphaNumericUnderscore

Property must contain only letters, numbers and underscores.

array

Property must be an array.

boolean

Property must be a boolean (true or false only).

contains

Property must contain the string specified in the second argument.

date

Property must be a date (Date object).

email

Property must be a valid e-mail address.

exists

Property must exist (not be undefined).

fn

Property must be a function.

in

Property must be in specified array.

credible
  .rule( { state: { in: ['approved', 'pending'] } } );

integer

Property must be an integer.

json

Property must be a valid JSON string.

length

Property must have a length matching specifications set in options.

Options

lowercase

Property must contain all lowercase letters.

luhn

Property must be a valid credit card number.

matches

Property must match RegExp object specified in second argument.

natural

Property must be a positive number.

naturalNonZero

Property must be a positive number greater than zero.

NaN

Property must not be a number (isNaN(value) returns false).

number

Property must be a number.

presence

Property must be defined and not empty.

object

Property must be an object.

operator

Compare property to a number or another property set in options.

Options

regexp

Property must be a regular expression (RegExp object).

string

Property must be a string.

uppercase

Property must contain all uppercase letters.

url

Property must be a valid URL.

License & Contributing

• Details on the license can be found here
• Details on running tests and contributing can be found here