diff --git a/.gitignore b/.gitignore new file mode 100644 index 000000000..814e6faa6 --- /dev/null +++ b/.gitignore @@ -0,0 +1,13 @@ +.DS_Store +.sauce + +node_modules +npm-debug.log + +build +components + +test/server/pid.txt + +/recurly.js +/recurly.min.js diff --git a/.travis.yml b/.travis.yml new file mode 100644 index 000000000..5f3af8d43 --- /dev/null +++ b/.travis.yml @@ -0,0 +1,15 @@ +language: node_js +script: make test-sauce +node_js: + - '0.10' +env: + global: + - secure: 'Q2BpyJZM/sgK5I9FRc2RqJ6LTQ3MR8Rk0Bs4BgzYE+QlsOS0mbwI5kjVwVCERu8+5MipD9pDXxeror3gnexQjtlD2DC2yhEvsjE1Q9nUc1fJO8yjH0LdRhcRj3i6cNciydTkvS/QJgi8mXO3Nfb+MDIhiBPyZbCfyj+yjcFgu2c=' + - secure: 'KFrQZYFBREY1xKAnnDJFUJaOwTn0sb4oHkFjhlSYzsTpDcWQEowPK72i8IOknf3r55qAuxi5VDKHcV/AcEGSSnG8Olopm3RZQ4mugPz/93lXg9lm73pT0tfK4jGPlQV7rYT4kkexy5F3LAW8ojSOTctGImIzgmm2Qm3RQJBBl5E=' + matrix: + - BROWSERS: 'chrome, safari, firefox, ie8..11' +notifications: + campfire: + rooms: + secure: VG1YCnwpSWtd/2wl+d0kyADt6zLWeXVFHXUVo7X0DndK/kRHIea3SAB5vBMAXWS84LvLaVKW7e9NFLsEjeJm1iIu8VzH6B4ersXm4Gr+ba+KLMNKXrWcqp0/1aluWy0ooIxa6zMICYpOZdOyOMhvxys8nESSNwDYdKnRsrjb7bw= + diff --git a/Makefile b/Makefile new file mode 100644 index 000000000..3dba2c908 --- /dev/null +++ b/Makefile @@ -0,0 +1,25 @@ +BIN= node_modules/.bin +COMPONENT= $(BIN)/component +MINIFY= $(BIN)/uglifyjs +DELEGATE= test test-browser test-sauce + +recurly.js: node_modules components $(SRC) + @$(COMPONENT) build --standalone recurly --name recurly --out . + @$(MINIFY) recurly.js --output recurly.min.js + +components: component.json + @$(COMPONENT) install + +node_modules: package.json + @npm install --silent + +$(DELEGATE): recurly.js + @cd test && make $@ + +clean: + @rm -rf components node_modules recurly.js recurly.min.js + @cd test && make $@ + +.PHONY: recurly.js +.PHONY: clean test test-browser +.PHONY: test-sauce test-coverage diff --git a/README.md b/README.md new file mode 100644 index 000000000..f5b74518a --- /dev/null +++ b/README.md @@ -0,0 +1,55 @@ +# Recurly.js 3 + +Zen subscription billing in the browser + +## Overview +This JavaScript library is included in a merchants form page and simplifies integration with +Recurly. When a user submits their credit card information, it is sent to the api.recurly.com and +a Recurly token is returned. This token is then sent to the merchant site, making it simple for +the merchant to be PCI compliant. + +If a purchase is being made on the page, the payment is reserved on the credit credit card when +the token is generated. If there is a problem processing the payment, the error can be displayed +on the form page simplifying the user experience and error management required on the merchant +server. + +3D Secure is transparently managed to the form developer by the RecurlyJS library and +api.recurly.com. + +## API Documentation + +[Recurly.js API Docs](https://docs.recurly.com/api/recurlyjs/v3beta) + +## Installation + +### Standard +```html + +``` + +### Component +**component.json** +```json +{ + "dependencies": { + "recurly/recurly-js-v3": "*" + } +} +``` +**index.html** +```html + +``` +[Learn more about component](http://github.com/component/component) + +## Build +```bash +$ make +``` + +## Test +```bash +$ make test +``` diff --git a/bower.json b/bower.json new file mode 100644 index 000000000..d74e8f271 --- /dev/null +++ b/bower.json @@ -0,0 +1,7 @@ +{ + "name": "recurly", + "version": "3.0.0-beta", + "main": "recurly.js", + "dependencies": {}, + "devDependencies": {} +} diff --git a/component.json b/component.json new file mode 100644 index 000000000..fd86f9ed6 --- /dev/null +++ b/component.json @@ -0,0 +1,47 @@ +{ + "name": "recurly", + "repo": "recurly/recurly-js", + "description": "Official Recurly JavaScript client for the browser.", + "version": "3.0.0-beta", + "keywords": [ + "recurly" + ], + "license": "MIT", + "main": "lib/index.js", + "dependencies": { + "chrissrogers/querystring": "*", + "chrissrogers/noop": "*", + "component/emitter": "*", + "component/indexof": "*", + "component/bind": "*", + "component/find": "*", + "component/each": "*", + "component/map": "*", + "yields/merge": "*", + "learnboost/jsonp": "*", + "visionmedia/debug": "*", + "component/type": "*", + "component/json": "*", + "kewah/mixin": "*", + "component/event": "*", + "danmilon/object.keys-shim": "*" + }, + "scripts": [ + "lib/index.js", + "lib/recurly.js", + "lib/version.js", + "lib/errors.js", + "lib/util/dom.js", + "lib/util/parse-card.js", + "lib/mixins/coupon.js", + "lib/mixins/paypal.js", + "lib/mixins/plan.js", + "lib/mixins/tax.js", + "lib/mixins/token.js", + "lib/mixins/validate.js", + "lib/mixins/pricing/index.js", + "lib/mixins/pricing/calculations.js", + "lib/mixins/pricing/binding.js" + ], + "remotes": [] +} diff --git a/example/advanced/advanced.css b/example/advanced/advanced.css new file mode 100644 index 000000000..1acbadef4 --- /dev/null +++ b/example/advanced/advanced.css @@ -0,0 +1,303 @@ +body { + background: white; + padding: 0; + margin: 0; + text-align: center; + font: 14px Helvetica, Arial, sans-serif; + color: #809cc9; + position: absolute; + left: 0; + right: 0; + top: 10%; + bottom: 0; + margin: auto; + -webkit-perspective: 1000; +} + +.payment * { + -webkit-backface-visibility: hidden; +} + +.payment { + border: 1px solid #e5e5e5; + border-radius: 4px; + position: relative; + width: 400px; + height: 450px; + text-align: left; + box-sizing: border-box; + display: inline-block; + -webkit-transform-style: preserve-3d; + -webkit-transition: all 0.5s linear; +} + +.payment-small { + height: 140px; +} + +.payment-flip { + -webkit-transform: rotateY(180deg); +} + +.payment-bottom, .payment-button { + -webkit-transition: background-color 200ms linear; + -moz-transition: background-color 200ms linear; + -o-transition: background-color 200ms linear; + -ms-transition: background-color 200ms linear; + transition: background-color 200ms linear; +} + +.payment-front, .payment-back { + position: absolute; + background: white; + width: 100%; + height: 100%; + border-radius: 4px; +} + +.payment-back { + background: white; + text-align: center; + box-sizing: border-box; + -webkit-transform: rotateY(180deg); +} + +.payment-cover { + overflow: hidden; + height: 100%; +} + +.payment-flip .payment-cover { + overflow: visible; +} + +.payment-top { + background: #52b2ef; + line-height: 38px; + color: #fff; + padding: 0 8px; +} + +.payment-back .payment-top { + background: #5abe12; +} + +.payment-mid { + padding: 0 10px; + position: relative; + z-index: 1; +} + +.payment-mid p { + margin: 16px 0; +} + +.payment-bottom { + position: absolute; + bottom: 0; + left: 0; + right: 0; + text-align: center; + line-height: 54px; + background: #f6f6f6; + border-radius: 0 0 4px 4px; + z-index: 2; +} + +input, select { + color: #0e2258; +} + +input { + padding: 6px 8px; + margin: 0 6px 0 0; + font-size: 12px; + letter-spacing: 0.04em; + width: 184px; + border: 1px solid #d0d4d7; + box-sizing: border-box; +} + +select { + border: 1px solid #d0d4d7; + background: white; +} + +.modern select { + line-height: 27px; + margin: 0; + padding: 0 24px 0 12px; + border-radius: 0; + -webkit-appearance: none; + -moz-appearance: none; + appearance: none; +} + +select::-ms-expand { + display: none; +} + +input[type=radio] { + width: auto; + margin: 0 4px 0 0; +} + +label { + margin: 0 6px 0 0; +} + +.payment-select { + position: relative; + display: inline-block; +} + +.modern .payment-select:after { + content: "\25BC"; + font-size: 10px; + color: #bbbfc2; + position: absolute; + top: 8px; + right: 9px; + pointer-events: none; + -webkit-backface-visibility: hidden; +} + +.payment-number { + width: 100%; + padding: 10px 8px; +} + +.payment-cvv { + width: 50px; + float: right; + margin-right: 0; +} + +.payment-cvv-hint { + font-size: 10px; + display: inline-block; + width: 100px; + float: right; + text-align: right; + padding: 4px 8px; +} + +.payment-last-name { + margin-right: 0; +} + +.payment-address { + width: 100%; +} + +.payment-city { + width: 220px; +} + +.payment-state { + width: 148px; +} + +.payment-zip { + width: 100px; +} + +.payment-country { + width: 268px; +} + +.payment-button { + background-color: #52b2ef; + border: none; + color: #fff; + border-radius: 4px; + text-shadow: 1px 1px 0 #1382c8; + font-size: 16px; + padding: 10px 20px; + outline: none; + cursor: pointer; + display: block; + margin: 20px auto 0; +} + +.payment-button:active { + box-shadow: none; + background-color: #1382c8; +} + +.payment-button:disabled { + background-color: #5abe12; + cursor: default; + text-shadow: 1px 1px 0 #448f0e; +} + +.payment-submitting .payment-mid { + -webkit-filter: blur(2px); + -moz-filter: blur(2px); + -o-filter: blur(2px); + -ms-filter: blur(2px); + filter: blur(2px); +} + +.payment-submitting .payment-front .payment-top { + background: #5abe12; + color: white; + text-shadow: 1px 1px 1px #507a32; +} + +.payment-error, +.payment-error-box, +.payment-error::-webkit-input-placeholder { + color: #d88c8a; +} + +.payment-error::-moz-placeholder { + color: #d88c8a; +} + +.payment-error { + border: 1px solid #d88c8a; + box-shadow: 0 0 2px #d88c8a inset; +} + +.payment-error-box { + border: 1px solid #d88c8a; + padding: 8px; + border-radius: 1px; + width: 100%; + position: absolute; + top: -60px; + box-sizing: border-box; + display: none; +} + +.payment-check { + position: relative; + display: inline-block; + vertical-align: top; + margin-right: 12px; + width: 200px; + height: 200px; +} + +.payment-check:before { + content: ''; + display: block; + position: absolute; + top: 50%; + left: 50%; + margin: -38px 0 0 -43px; + height: 33px; + width: 77px; + border: solid #85d54a; + border-width: 0 0 24px 24px; + -webkit-transform: rotate(-45deg); + -moz-transform: rotate(-45deg); + -ms-transform: rotate(-45deg); + -o-transform: rotate(-45deg); + transform: rotate(-45deg); +} + +#token-out { + font-size: 24px; +} diff --git a/example/advanced/index.html b/example/advanced/index.html new file mode 100644 index 000000000..655c68f7a --- /dev/null +++ b/example/advanced/index.html @@ -0,0 +1,259 @@ + + + + + recurly.js example + + + + + + +
+
+
+
+
+
+ This is a secure 128-bit SSL encrypted payment +
+
+

+ + + + +

+
+

+ +

+

+ + + + + + + + the 3 digits on the back of your card +

+

+ + +

+ Address +

+ +

+

+ + + + +

+

+ + + + +

+
+
+ +
+ + +
+
+ You will be charged $29 monthly +
+
+
+
+
+ Thanks for signing up! +
+

+ +

+

+ Here's your token from Recurly +

+

+ :) +

+
+
+ +
+ + + diff --git a/example/paypal/index.html b/example/paypal/index.html new file mode 100644 index 000000000..1cf918d77 --- /dev/null +++ b/example/paypal/index.html @@ -0,0 +1,41 @@ + + + + recurly.js example + + + + +
+

$29 -- pay me, yeah?

+
+ + +
+ + + diff --git a/example/pricing-addons/index.html b/example/pricing-addons/index.html new file mode 100644 index 000000000..bed4e81bd --- /dev/null +++ b/example/pricing-addons/index.html @@ -0,0 +1,152 @@ + + + + recurly.js example + + + + + +
+ + + + + + + + + + + + + + + + + +

Add-ons

+

+ +

Coupon

+ + + + + + + + + +

+ Due now +

+ +

+ Due later +

+ + +
+
+ + + diff --git a/example/pricing/index.html b/example/pricing/index.html new file mode 100644 index 000000000..62f514f9f --- /dev/null +++ b/example/pricing/index.html @@ -0,0 +1,128 @@ + + + + recurly.js example + + + + + +
+ + + + + + + + + + + + + + + + + +

Coupon

+ + + + + + + + + +

+ Due now +

+ +

+ Due later +

+ + +
+
+ + + diff --git a/example/simple/index.html b/example/simple/index.html new file mode 100644 index 000000000..f14604d11 --- /dev/null +++ b/example/simple/index.html @@ -0,0 +1,56 @@ + + + + recurly.js example + + + + + +
+ + + + + + + + + + + + +
+
+ + + diff --git a/lib/errors.js b/lib/errors.js new file mode 100644 index 000000000..5ec24b912 --- /dev/null +++ b/lib/errors.js @@ -0,0 +1,162 @@ +/** + * dependencies + */ + +var mixin = require('mixin'); + +/** + * Export `errors`. + */ + +module.exports = exports = errors; + +/** + * Error accessor. + * + * @param {String} name + * @param {Object} options + * @return {Error} + */ + +function errors (name, options) { + return errors.get(name, options); +} + +/** + * Defined errors. + * + * @type {Object} + * @private + */ + +errors.map = {}; + +/** + * Base url for documention. + * + * @type {String} + * @private + */ + +errors.baseURL = ''; + +/** + * Sets the `baseURL` for docs. + * + * @param {String} url + * @public + */ + +errors.doc = function (baseURL) { + errors.baseURL = baseURL; +}; + +/** + * Gets errors defined by `name`. + * + * @param {String} name + * @param {Object} context + * @return {Error} + * @public + */ + +errors.get = function (name, context) { + if (!(name in errors.map)) { + throw new Error('invalid error'); + } else { + return new errors.map[name](context); + } +}; + +/** + * Registers an error defined by `name` with `config`. + * + * @param {String} name + * @param {Object} config + * @return {Error} + * @public + */ + +errors.add = function (name, config) { + config = config || {}; + + function RecurlyError (context) { + Error.call(this); + + this.name = name; + this.message = config.message; + mixin(this, context || {}); + + if (config.help) { + this.help = errors.baseURL + config.help; + this.message += ' (need help? ' + this.help + ')'; + } + }; + + RecurlyError.prototype = new Error(); + return errors.map[name] = RecurlyError; +}; + +/** + * Internal definations. + * + * TODO(gjohnson): open source this as a component + * and move these out. + */ + +errors.doc('https://docs.recurly.com/api/recurlyjs/v3beta'); + +errors.add('already-configured', { + message: 'Configuration may only be set once.', + help: '#identify-your-site' +}); + +errors.add('not-configured', { + message: 'Not configured. You must first call recurly.configure().', + help: '#identify-your-site' +}); + +errors.add('missing-public-key', { + message: 'The publicKey setting is required.', + help: '#identify-your-site' +}); + +errors.add('api-error', { + message: 'There was an error with your request.' +}); + +errors.add('validation', { + message: 'There was an error validating your request.' +}); + +errors.add('missing-callback', { + message: 'Missing callback' +}); + +errors.add('invalid-options', { + message: 'Options must be an object' +}); + +errors.add('missing-plan', { + message: 'A plan must be specified.' +}); + +errors.add('missing-coupon', { + message: 'A coupon must be specified.' +}); + +errors.add('invalid-item', { + message: 'The given item does not appear to be a valid recurly plan, coupon, addon, or taxable address.' +}); + +errors.add('invalid-addon', { + message: 'The given addon_code is not among the valid addons for the specified plan.' +}); + +errors.add('invalid-currency', { + message: 'The given currency is not among the valid codes for the specified plan.' +}); + +errors.add('unremovable-item', { + message: 'The given item cannot be removed.' +}); diff --git a/lib/index.js b/lib/index.js new file mode 100644 index 000000000..4ffeccf4a --- /dev/null +++ b/lib/index.js @@ -0,0 +1,18 @@ + +/*! + * Module dependencies. + */ + +var Recurly = require('./recurly'); + +/** + * Export a single instance. + */ + +module.exports = exports = new Recurly(); + +/** + * Hack for testing. + */ + +exports.Recurly = Recurly; diff --git a/lib/mixins/coupon.js b/lib/mixins/coupon.js new file mode 100644 index 000000000..70f0b24cf --- /dev/null +++ b/lib/mixins/coupon.js @@ -0,0 +1,41 @@ + +/*! + * Module dependencies. + */ + +var type = require('type'); +var debug = require('debug')('recurly:coupon'); +var errors = require('../errors'); + +/** + * Coupon mixin. + * + * Retrieves coupon information for the `plan`. The `callback` signature + * is `err, plan` where `err` may be a request or server error, and `plan` + * is a representation of the requested plan. + * + * @param {Object} options + * @param {Function} callback + */ + +exports.coupon = function (options, callback) { + debug('%j', options); + + if ('function' !== type(callback)) { + throw errors('missing-callback'); + } + + if ('object' !== type(options)) { + throw errors('invalid-options'); + } + + if (!('plan' in options)) { + throw errors('missing-plan'); + } + + if (!('coupon' in options)) { + throw errors('missing-coupon'); + } + + this.request('/plans/' + options.plan + '/coupons/' + options.coupon, options, callback); +}; diff --git a/lib/mixins/paypal.js b/lib/mixins/paypal.js new file mode 100644 index 000000000..471804f0c --- /dev/null +++ b/lib/mixins/paypal.js @@ -0,0 +1,18 @@ + +/*! + * Module dependencies. + */ + +var debug = require('debug')('recurly:paypal'); + +/** + * Paypal mixin. + * + * @param {Object} data + * @param {Function} done callback + */ + +exports.paypal = function (data, done) { + debug('start'); + this.open('/paypal/start', data, done); +}; diff --git a/lib/mixins/plan.js b/lib/mixins/plan.js new file mode 100644 index 000000000..eee118a13 --- /dev/null +++ b/lib/mixins/plan.js @@ -0,0 +1,32 @@ + +/*! + * Module dependencies. + */ + +var type = require('type'); +var debug = require('debug')('recurly:plan'); + +/** + * Plan mixin. + * + * Retrieves information for the `plan`. The `callback` signature + * is `err, plan` where `err` may be a request or server error, and `plan` + * is a representation of the requested plan. + * + * @param {String} code + * @param {Function} callback + */ + +exports.plan = function (code, callback) { + debug('%s', code); + + if ('function' != type(callback)) { + throw new Error('Missing callback'); + } + + if ('undefined' == type(code)) { + return callback(new Error('Missing plan code')); + } + + this.request('/plans/' + code, callback); +}; diff --git a/lib/mixins/pricing-old.js b/lib/mixins/pricing-old.js new file mode 100644 index 000000000..4ee28048d --- /dev/null +++ b/lib/mixins/pricing-old.js @@ -0,0 +1,249 @@ +/** + * dependencies + */ + +var index = require('indexof'); +var each = require('each'); +var find = require('find'); +var type = require('type'); +var events = require('event'); +var errors = require('../errors'); + +/** + * expose + */ + +exports.pricing = function (elem) { + return new Pricing(this, elem); +}; + +/** + * + */ + +var PRICEABLE_OBJECTS = ['plan', 'addon', 'coupon', 'tax']; + +/** + * Estimates subscription costs. + * + * --- API --- + * + * var pricing = recurly.pricing() + * .add({ plan: 'plan_code' }) + * .add({ addon: 'addon_' }) + * .add({ coupon: coupon }) + * .add({ tax: address }); + * + * pricing.remove({ coupon: coupon }); + * pricing.remove({ addon: addon }); + * pricing.remove('tax'); + * + * pricing.price(); + * + * { + * now: { subtotal: 57, tax: 2.95 total: 89.95 }, + * next: { subtotal: 57, tax: 2.95, total: 59.95 }, + * symbol: '$' + * } + * + * --- DOM binding --- + * + * recurly.pricing(container); + * + * TODO: + * the calculator can get in a weird state if plan is switched + * and the other items are not. Should check item validity when + * switching plans. Also should check that the addon and coupon can + * be applied to the given plan. + * + * @param {Recurly} recurly + * @param {HTMLElement} [elem] DOM element containing fields to bind to priced objects + * @public + */ + +function Pricing (recurly, elem) { + this.items = {}; + this.items.addons = []; + this.recurly = recurly; + if (elem) this.binding(this.recurly.dom.element(elem)); +} + +/** + * Provides a subscription price estimate + * + * @param {String} [currency] + * @param {Function} done + * @public + */ + +Pricing.prototype.price = function price (currency, done) { + if (!done) { + done = currency; + currency = null; + } + + if ('function' !== type(done)) throw errors('missing-callback'); + if (!this.plan) throw errors('missing-plan'); + + currency = currency || this.recurly.config.currency; + + var now = {}; + var next = {}; + + var plan = this.items.plan; + var coupon = this.items.coupon; + var addons = this.items.addons; + var tax = this.items.tax; // TODO: tax exemption? + var trial = plan.trial; + var planPrice = plan.price[currency]; + + now.subtotal = next.subtotal = planPrice.unit_amount_in_cents * plan.quantity; + + if (trial) now.subtotal = 0; + + each(addons, function (addon) { + var price = addon.price[currency].unit_amount_in_cents * addon.quantity; + if (trial) { + next.subtotal += price; + } else { + now.subtotal += price; + next.subtotal += price; + } + }); + + if (coupon) { + if (coupon.rate) { + now.subtotal -= now.subtotal * coupon.rate; + next.subtotal -= next.subtotal * coupon.rate; + } else { + now.subtotal -= coupon.discount_in_cents[currency]; + next.subtotal -= coupon.discount_in_cents[currency]; + } + } + + now.subtotal += planPrice.setup_fee_in_cents; + + now.tax = 0; + next.tax = 0; + + now.total = now.subtotal; + next.total = next.subtotal; + + if (tax) this.recurly.tax(tax.address, applyTax); + else finish(); + + function applyTax (err, taxes) { + if (err) return finish(err); + each(taxes, function (tax) { + now.tax += now.subtotal * tax.rate; + next.tax += next.subtotal * tax.rate; + }); + now.total += now.tax; + next.total += next.tax; + finish(); + } + + function finish (err) { + each(now, function (name, amount) { now[name] = decimal(amount) }); + each(next, function (name, amount) { next[name] = decimal(amount) }); + done(err, { + now: now, + next: next, + symbol: planPrice.symbol + }); + } +}; + +/** + * adds pricable objects + * + * @param {Object} map of plan, addon, coupon, tax + * @return {this} + * @public + */ + +Pricing.prototype.add = function (items) { + each(items, function (type, obj) { + if (!~index(PRICEABLE_OBJECTS, type)) throw errors('invalid-item'); + this[type](obj); + }); + return this; +}; + +/** + * removes an object from the pricing calculator + * + * @param {Object} item one of plan, addon, or coupon + * @return {this} + * @public + */ + +Pricing.prototype.remove = function (item) { + switch (which(item)) { + case 'plan': delete this.items.plan; break; + case 'coupon': delete this.items.coupon; break; + case 'addon': this.items.addons.splice(index(this.items.addons, item)); break; + default: throw errors('invalid-item'); + } + return this; +}; + +/** + * adds a plan, [] + * + * @param {Object} plan + */ + +Pricing.prototype.plan = function (plan) { + plan.quantity = plan.quantity || 1; + this.items.plan = plan; +}; + +/** + * adds an addon, [which must apply to the selected plan] + * + * @param {Object} addon + * @return {this} + * @public + */ + +Pricing.prototype.addon = function (addon) { + if (typeof addon === 'string') { + addon = find(this.items.plan.addons, { addon_code: addon }); + } + this.remove(addon); + addon.quantity = addon.quantity || 1; + this.items.addons.push(addon); +}; + +/** + * adds a coupon, [which must apply to the selected plan] + * + * @param {Object} coupon + * @return {this} + * @public + */ + +Pricing.prototype.coupon = function (coupon) { + if (which(coupon) !== 'coupon') throw errors('invalid-coupon'); + this.items.coupon = coupon; +}; + +/** + * attaches customer tax information + * + * TODO: address checking? + * + * @param {Object} address + * @return {this} + * @public + */ + +Pricing.prototype.tax = function (address) { + delete this.items.tax; + this.items.tax = { address: address }; +}; + +function decimal (number) { + return Math.round(Math.max(number, 0)) / 100; +} diff --git a/lib/mixins/pricing/binding.js b/lib/mixins/pricing/binding.js new file mode 100644 index 000000000..ff9d199c1 --- /dev/null +++ b/lib/mixins/pricing/binding.js @@ -0,0 +1,99 @@ +/** + * dependencies + */ + +var each = require('each'); +var events = require('event'); +var find = require('find'); +var index = require('indexof'); +var dom = require('../../util/dom'); + +/** + * bind a dom element to pricing values + * + * TODO + * - move this into a plugin? + * - better name? + * + * @param {HTMLElement} el + */ + +exports.binding = function (el) { + var self = this; + var elems = {}; + var el = dom.element(el); + + if (!el) throw new Error('invalid dom element'); + + if (this.binding.unbind) this.binding.unbind(); + + self.on('change', update); + + each(el.querySelectorAll('[data-recurly]'), function (elem) { + if (!elems[elem.dataset.recurly]) elems[elem.dataset.recurly] = []; + elems[elem.dataset.recurly].push(elem); + events.bind(elem, 'change', change); + events.bind(elem, 'propertychange', change); + }); + + this.binding.unbind = unbind; + + change(); + + function change (event) { + var target = event && event.target && event.target.dataset.recurly; + var all = !target; + + if (~index(['country', 'postal_code'], target) || all) { + if (elems.country && elems.postal_code) { + var address = { + country: dom.value(elems.country) + , postal_code: dom.value(elems.postal_code) + }; + + self.set({ address: address}); + } + } + + self.set({ plan: dom.value(elems.plan) }, function (err, plan) { + if (all || target === 'currency') self.set({ currency: dom.value(elems.currency) }); + + if ((all || target === 'addon') && elems.addon) { + each(elems.addon, function (node) { + var addonCode = node.dataset.recurlyAddon; + if (plan.addons && find(plan.addons, { code: addonCode })) { + self.set({ addon: addonCode }, { quantity: node.value }); + } + }); + } + + if ((all || target === 'coupon') && elems.coupon) { + self.set({ coupon: dom.value(elems.coupon) }); + } + }); + }; + + function update (price) { + dom.value(elems.currency_code, price.currency.code); + dom.value(elems.currency_symbol, price.currency.symbol); + each(['subtotal', 'tax', 'total'], function (value) { + dom.value(elems[value + '_now'], price.now[value]); + dom.value(elems[value + '_next'], price.next[value]); + }); + if (elems.addon_price) { + each(elems.addon_price, function (elem) { + var addonPrice = price.addons[elem.dataset.recurlyAddon]; + if (addonPrice) dom.value(elem, addonPrice); + }); + } + } + + function unbind () { + each(elems, function (name, elems) { + each(elems, function (elem) { + events.unbind(elem, 'change', change); + events.unbind(elem, 'propertychange', change); + }, this); + }, this); + } +}; diff --git a/lib/mixins/pricing/calculations.js b/lib/mixins/pricing/calculations.js new file mode 100644 index 000000000..9ac1d9ce5 --- /dev/null +++ b/lib/mixins/pricing/calculations.js @@ -0,0 +1,181 @@ +/** + * dependencies + */ + +var each = require('each'); +var bind = require('bind'); +var find = require('find'); + +/** + * expose + */ + +module.exports = Calculations; + +/** + * Subscription calculation calculation + * + * @param {Pricing} pricing + * @constructor + * @public + */ + +function Calculations (pricing, done) { + if (!(this instanceof Calculations)) { + return new Calculations(pricing, done); + } + + this.pricing = pricing; + this.items = pricing.items; + + this.price = { + now: {}, + next: {}, + addons: {}, + currency: { + code: this.items.currency, + symbol: this.planPrice().symbol + } + }; + + this.subtotal(); + this.tax(function () { + this.total(); + each(this.price.now, decimal, this.price.now); + each(this.price.next, decimal, this.price.next); + each(this.price.addons, decimal, this.price.addons); + done(this.price); + }); +} + +/** + * Calculates subtotal + * + * @private + */ + +Calculations.prototype.subtotal = function () { + var subtotal = this.planPrice().unit_amount_in_cents; + + this.price.now.subtotal = subtotal; + this.price.next.subtotal = subtotal; + + if (this.items.plan.trial) this.price.now.subtotal = 0; + + this.addons(); + this.coupon(); + this.setupFee(); +}; + +/** + * Calculates tax + * + * @param {Function} done + * @private + */ + +Calculations.prototype.tax = function (done) { + this.price.now.tax = 0; + this.price.next.tax = 0; + + if (this.items.address) { + var self = this; + this.pricing.recurly.tax(this.items.address, function applyTax (err, taxes) { + if (err) self.pricing.emit('error', err); + else each(taxes, function (tax) { + if (tax.type === 'usst' && self.items.plan.tax_exempt) return; + self.price.now.tax += self.price.now.subtotal * tax.rate; + self.price.next.tax += self.price.next.subtotal * tax.rate; + }); + done.call(self); + }); + } else done.call(this); +}; + +/** + * Calculates total + * + * @private + */ + +Calculations.prototype.total = function () { + this.price.now.total = this.price.now.subtotal + this.price.now.tax; + this.price.next.total = this.price.next.subtotal + this.price.next.tax; +}; + +/** + * Computes addon prices and applies addons to the subtotal + * + * @private + */ + +Calculations.prototype.addons = function () { + each(this.items.plan.addons, function (addon) { + var price = addon.price[this.items.currency].unit_amount_in_cents; + + this.price.addons[addon.code] = price; + + var selected = find(this.items.addons, { code: addon.code }); + if (selected) { + price = price * selected.quantity; + if (this.items.plan.trial) { + this.price.next.subtotal += price; + } else { + this.price.now.subtotal += price; + this.price.next.subtotal += price; + } + } + }, this); +}; + +/** + * Applies coupon to the subtotal + * + * @private + */ + +Calculations.prototype.coupon = function () { + var coupon = this.items.coupon; + if (coupon) { + if (coupon.discount.rate) { + this.price.now.subtotal -= this.price.now.subtotal * coupon.discount.rate; + this.price.next.subtotal -= this.price.next.subtotal * coupon.discount.rate; + } else { + this.price.now.subtotal -= coupon.discount.amount_in_cents[this.items.currency]; + this.price.next.subtotal -= coupon.discount.amount_in_cents[this.items.currency]; + } + } +}; + +/** + * Applies plan setup fee to the subtotal + * + * @private + */ + +Calculations.prototype.setupFee = function () { + this.price.now.subtotal += this.planPrice().setup_fee_in_cents; +}; + +/** + * Get the price structure of a plan based on currency + * + * @return {Object} + * @private + */ + +Calculations.prototype.planPrice = function () { + return this.items.plan.price[this.items.currency]; +}; + +/** + * Applies a cent -> decimal transform on an object's member + * + * @param {String} prop Property on {this} to transform + * @this {Object} on which to apply decimal transformation + * @private + */ + +function decimal (prop) { + this[prop] = (Math.round(Math.max(this[prop], 0)) / 100).toFixed(2); +} diff --git a/lib/mixins/pricing/index.js b/lib/mixins/pricing/index.js new file mode 100644 index 000000000..b3541667c --- /dev/null +++ b/lib/mixins/pricing/index.js @@ -0,0 +1,356 @@ +/** + * dependencies + */ + +var Emitter = require('emitter'); +var index = require('indexof'); +var each = require('each'); +var type = require('type'); +var bind = require('bind'); +var find = require('find'); +var mixin = require('mixin'); +var keys = require('object.keys-shim'); +var json = require('json'); +var noop = require('noop'); +var debug = require('debug')('recurly:pricing'); +var Calculations = require('./calculations'); +var errors = require('../../errors'); + +/** + * expose + */ + +exports.Pricing = Pricing; + +/** + * subscription properties + */ + +var PROPERTIES = [ + 'plan' + , 'addon' + , 'coupon' + , 'address' + , 'currency' +]; + +/** + * Pricing + * + * TODO + * - then/promise over callbacks? + * + * @constructor + * @param {Recurly} recurly + * @public + */ + +function Pricing (recurly) { + if (this instanceof require('../../recurly')) return new Pricing(this); + this.recurly = recurly; + this.reset(); +} + +Emitter(Pricing.prototype); + +/** + * Resets the pricing calculator + * + * @public + */ + +Pricing.prototype.reset = function () { + this.items = {}; + this.items.addons = []; + this.set({ currency: this.recurly.config.currency }); +}; + +/** + * Adds an object to the pricing model + * + * example + * + * .set({ plan: 'plan_code' }); + * .set({ addon: 'addon_code' }); + * .set({ addon: { addon_code: 2 } }); + * .set({ coupon: 'coupon_code' }); + * .set({ address: { country: 'US', postal_code: '94117' } }); + * + * @param {Object} opts + * @param {Object} meta + * @param {Function} done + * @public + */ + +Pricing.prototype.set = function (opts, meta, done) { + if (type(meta) === 'function') { + done = meta; + delete meta; + } + + done = done || noop; + + var self = this; + for (var prop in opts) { + var obj = opts[prop]; + if (!~index(PROPERTIES, prop)) return this.emit('error', errors('invalid-item')); + this[prop](obj, meta || {}, function () { + var args = arguments; + self.reprice(function () { + done.apply(self, args); + }); + }); + break; + } +}; + +/** + * Removes an object from the pricing model + * + * example + * + * .remove({ plan: 'plan_code' }); + * .remove({ addon: 'addon_code' }); + * .remove({ coupon: 'coupon_code' }); + * .remove({ address: true }); // to remove without specifying a code + * + * @param {Object} opts + * @param {Functon} done + * @public + */ + +Pricing.prototype.remove = function (opts, done) { + debug('remove'); + done = done || noop; + var item; + + for (var prop in opts) { + var id = opts[prop]; + if (!~index(PROPERTIES, prop)) return this.emit('error', errors('invalid-item')); + if (prop === 'addon') { + var pos = index(this.items.addons, find(this.items.addons, { code: id })); + if (~pos) { + item = this.items.addons.splice(pos); + } + } else if (this.items[prop] && (id === this.items[prop].code || id === true)) { + item = this.items[prop] + delete this.items[prop]; + } else { + var err = errors('unremovable-item', { + type: prop + , id: id + , reason: 'does not currently exist on pricing calculation.' + }); + this.emit('error', err); + return done(err); + } + break; + } + + done(null, item); +}; + +/** + * Provides a subscription price estimate using current state + * + * @param {Function} done + * @private + */ + +Pricing.prototype.reprice = function (done) { + if (!this.items.plan) return; + var self = this; + + Calculations(this, function (price) { + if (json.stringify(price) === json.stringify(self.price)) return done(null, price); + self.price = price; + self.emit('change', price); + done(null, price); + }); +}; + +/** + * Updates plan + * + * @param {String} plan_code + * @param {Object} meta + * @param {Function} done + * @private + */ + +Pricing.prototype.plan = function (plan_code, meta, done) { + if (this.items.plan && this.items.plan.code === plan_code) { + return done(null, this.items.plan); + } + + var self = this; + this.recurly.plan(plan_code, function (err, plan) { + if (err) { + self.emit('error', err); + return done(err); + } + + self.items.plan = plan; + + if (!(self.items.currency in plan.price)) { + self.currency(keys(plan.price)[0]); + } + + debug('set.plan`'); + self.emit('set.plan', plan); + done(null, plan); + }); +}; + +/** + * Updates addon + * + * @param {String} addon_code + * @param {Object} meta + * @param {Number} meta.quantity + * @param {Function} done + * @private + */ + +Pricing.prototype.addon = function (addon_code, meta, done) { + if (!this.items.plan) { + var err = errors('missing-plan'); + this.emit('error', err); + return done(err); + } + + var planAddon = this.items.plan.addons && find(this.items.plan.addons, { code: addon_code }); + if (!planAddon) { + var err = errors('invalid-addon', { + planCode: this.items.plan.code + , addonCode: addon_code + }); + this.emit('error', err); + return done(err); + } + + var quantity = addonQuantity(meta, planAddon); + var addon = find(this.items.addons, { code: addon_code}); + + if (isNaN(quantity) || quantity === 0) { + return this.remove({ addon: addon_code }, done); + } + + if (addon) { + addon.quantity = quantity; + } else { + var addon = json.parse(json.stringify(planAddon)); + addon.quantity = quantity; + this.items.addons.push(addon); + } + + debug('set.addon'); + this.emit('set.addon', addon); + done(null, addon); +}; + +/** + * Updates coupon + * + * @param {String} coupon_code + * @param {Object} meta + * @param {Function} done + * @private + */ + +Pricing.prototype.coupon = function (coupon_code, meta, done) { + if (!this.items.plan) { + var err = errors('missing-plan'); + this.emit('error', err); + return done(err); + } + + if (this.items.coupon && this.items.coupon.code === coupon_code) { + return done(null, this.items.coupon); + } + + if (this.items.coupon) { + this.remove({ coupon: this.items.coupon.code }); + } + + if (!coupon_code) return done(); + + var self = this; + this.recurly.coupon({ plan: this.items.plan.code, coupon: coupon_code }, function (err, coupon) { + if (err) { + self.emit('error', err); + return done(err); + } + + self.items.coupon = coupon; + + debug('set.coupon'); + self.emit('set.coupon', coupon); + done(null, coupon); + }); +}; + +/** + * Updates address + * + * @param {Object} address + * @param {String} address.country + * @param {String|Number} address.postal_code + * @param {Object} meta + * @param {Function} done + * @private + */ + +Pricing.prototype.address = function (address, meta, done) { + if (json.stringify(address) === json.stringify(this.items.address)) { + return done(null, this.items.address); + } + + this.items.address = address; + + debug('set.address'); + this.emit('set.address', address); + done(null, address); +}; + +/** + * Updates or retrieves currency code + * + * @param {String} [code] + * @param {Object} meta + * @param {Function} done + * @private + */ + +Pricing.prototype.currency = function (code, meta, done) { + if (this.items.currency === code) { + return done(null, this.items.currency); + } + + if (this.items.plan && !(code in this.items.plan.price)) { + var err = errors('invalid-currency', { + currencyCode: code + , planCurrencies: keys(this.items.plan.price) + }); + this.emit('error', err); + return done(err); + } + + this.items.currency = code; + + debug('set.currency'); + this.emit('set.currency', code); + done(null, code); +}; + +mixin(Pricing.prototype, require('./binding')); + +function addonQuantity (meta, planAddon) { + var qty = meta.quantity !== undefined + ? meta.quantity + : planAddon.quantity !== undefined + ? planAddon.quantity + : 1; + + return parseInt(qty, 10); +} diff --git a/lib/mixins/tax.js b/lib/mixins/tax.js new file mode 100644 index 000000000..6c676268d --- /dev/null +++ b/lib/mixins/tax.js @@ -0,0 +1,32 @@ + +/*! + * Module dependencies. + */ + +var type = require('type'); +var debug = require('debug')('recurly:tax'); + +/** + * Tax mixin. + * + * Provides a tax estiamte for the given address. + * + * TODO: It mentions address above, what all fields are required? + * + * @param {Object} options + * @param {Function} callback + */ + +exports.tax = function (options, callback) { + debug('%j', options); + + if ('function' != type(callback)) { + throw new Error('Missing callback'); + } + + if (!('currency' in options)) { + options.currency = this.config.currency; + } + + this.request('/tax', options, callback); +}; diff --git a/lib/mixins/token.js b/lib/mixins/token.js new file mode 100644 index 000000000..edf92c403 --- /dev/null +++ b/lib/mixins/token.js @@ -0,0 +1,141 @@ + +/*! + * Module dependencies. + */ + +var bind = require('bind'); +var each = require('each'); +var type = require('type'); +var index = require('indexof'); +var debug = require('debug')('recurly:token'); +var dom = require('../util/dom'); +var parseCard = require('../util/parse-card'); +var errors = require('../errors'); + +/** + * Fields that are sent to API. + * + * @type {Array} + * @private + */ + +var fields = [ + 'first_name' + , 'last_name' + , 'number' + , 'month' + , 'year' + , 'cvv' + , 'address1' + , 'address2' + , 'country' + , 'city' + , 'state' + , 'zip' + , 'token' +]; + +/** + * Generates a token from customer data. + * + * The callback signature: `err, response` where `err` is a + * connection, request, or server error, and `response` is the + * recurly service response. The generated token is accessed + * at `response.token`. + * + * @param {Object|HTMLFormElement} options Billing properties or an HTMLFormElement + * with children corresponding to billing properties via 'data-reurly' attributes. + * @param {String} options.first_name customer first name + * @param {String} options.last_name customer last name + * @param {String|Number} options.number card number + * @param {String|Number} options.month card expiration month + * @param {String|Number} options.year card expiration year + * @param {String|Number} options.cvv card verification value + * @param {String} [options.address1] + * @param {String} [options.address2] + * @param {String} [options.country] + * @param {String} [options.city] + * @param {String} [options.state] + * @param {String|Number} [options.zip] + * @param {Function} done callback + */ + +exports.token = function (options, done) { + var open = bind(this, this.open); + var data = normalize(options); + var input = data.values; + var userErrors = validate.call(this, input); + + if ('function' !== type(done)) { + throw errors('missing-callback'); + } + + if (userErrors.length) { + return done(errors('validation', { fields: userErrors })); + } + + this.request('/token', input, function (err, res) { + if (err) return done(err); + if (data.fields.token && res.id) { + data.fields.token.value = res.id; + } + done(null, res); + }); +}; + +/** + * Parses options out of a form element and normalizes according to rules. + * + * @param {Object|HTMLFormElement} options + * @return {Object} + */ + +function normalize (options) { + var el = dom.element(options); + var data = { fields: {}, values: {} }; + + if (el && 'form' === el.nodeName.toLowerCase()) { + each(el.querySelectorAll('[data-recurly]'), function (field) { + var name = field.dataset.recurly; + if (~index(fields, name)) { + data.fields[name] = field; + data.values[name] = dom.value(field); + } + }); + } else { + data.values = options; + } + + data.values.number = parseCard(data.values.number); + + return data; +} + +/** + * Checks user input on a token call + * + * @param {Object} input + * @return {Array} indicates which fields are not valid + */ + +function validate (input) { + var errors = []; + + if (!this.validate.cardNumber(input.number)) { + errors.push('number'); + } + + if (!this.validate.expiry(input.month, input.year)) { + errors.push('month', 'year'); + } + + if (!input.first_name) { + errors.push('first_name'); + } + + if (!input.last_name) { + errors.push('last_name'); + } + + return errors; +} diff --git a/lib/mixins/validate.js b/lib/mixins/validate.js new file mode 100644 index 000000000..ece449b31 --- /dev/null +++ b/lib/mixins/validate.js @@ -0,0 +1,135 @@ + +/*! + * Module dependencies. + */ + +var find = require('find'); +var index = require('indexof'); +var parseCard = require('../util/parse-card'); + +/** + * Card patterns. + * + * @private + */ + +var types = [ + { + type: 'discover', + pattern: /^(6011|622|64[4-9]|65)/, + lengths: [16] + } + , { + type: 'master', + pattern: /^5[0-5]/, + lengths: [16] + } + , { + type: 'american_express', + pattern: /^3[47]/, + lengths: [15] + } + , { + type: 'visa', + pattern: /^4/, + lengths: [13, 16] + } + , { + type: 'jcb', + pattern: /^35[2-8]\d/, + lengths: [16] + } + , { + type: 'diners_club', + pattern: /^(30[0-5]|309|36|3[89]|54|55|2014|2149)/, + lengths: [14] + } +]; + +/** + * Validate mixin. + * + * @public + */ + +exports.validate = { + + /** + * Validates a credit card number via luhn algorithm. + * + * @param {Number|String} number The card number. + * @return {Boolean} + * @see https://sites.google.com/site/abapexamples/javascript/luhn-validation + */ + + cardNumber: function (number) { + var str = parseCard(number); + var ca, sum = 0, mul = 1; + var i = str.length; + + while (i--) { + ca = parseInt(str.charAt(i), 10) * mul; + sum += ca - (ca > 9) * 9; + mul ^= 3; + } + + return sum % 10 === 0 && sum > 0; + }, + + /** + * Returns the type of the card number as a string. + * + * TODO(chrissrogers): Maybe undefined instread of "unknown"? + * + * @param {Number|String} number The card number + * @return {String} card type + */ + + cardType: function (number) { + var str = parse(number); + var card = find(types, function (card) { + return card.pattern.test(str) && ~index(card.lengths, str.length); + }); + return card && card.type || 'unknown'; + }, + + /** + * Validates whether an expiry month is present or future. + * + * @param {Numer|String} month The 2 digit month + * @param {Numer|String} year The 2 or 4 digit year + * @return {Boolean} + */ + + expiry: function (month, year) { + month = parseInt(month, 10) - 1; + if (month < 0 || month > 11) return false; + year = parseInt(year, 10); + year += year < 100 ? 2000 : 0; + + var expiry = new Date; + expiry.setYear(year); + expiry.setDate(1); + expiry.setHours(0); + expiry.setMinutes(0); + expiry.setSeconds(0); + expiry.setMonth(month + 1); + return new Date < expiry; + }, + + /** + * Validates whether a number looks like a cvv. + * + * e.g.: '123', '0321' + * + * @param {Number|String} number The card verification value + * @return {Boolean} + */ + + cvv: function (number) { + if (isNaN(number)) return false; + var len = number.toString().length; + return len === 3 || len === 4; + } + +}; diff --git a/lib/recurly.js b/lib/recurly.js new file mode 100644 index 000000000..42df3ea8b --- /dev/null +++ b/lib/recurly.js @@ -0,0 +1,278 @@ + +/*! + * Module dependencies. + */ + +var bind = require('bind'); +var json = require('json'); +var each = require('each'); +var type = require('type'); +var merge = require('merge'); +var mixin = require('mixin'); +var jsonp = require('jsonp'); +var events = require('event'); +var qs = require('querystring'); +var Emitter = require('emitter'); +var errors = require('./errors'); +var version = require('./version'); +var debug = require('debug')('recurly'); + +/** + * Default configuration values. + * + * @private + * @type {Object} + */ + +var defaults = { + currency: 'USD' + , timeout: 60000 + , publicKey: '' + , api: 'https://api.recurly.com/js/v1' +}; + +/** + * API mixins. + * + * @type {Array} + * @private + */ + +var mixins = [ + 'coupon' + , 'paypal' + , 'plan' + , 'tax' + , 'token' + , 'pricing' + , 'validate' +]; + +/** + * Export `Recurly`. + */ + +module.exports = Recurly; + +/** + * Initialize defaults. + * + * @param {Object} options + * @constructor + * @public + */ + +function Recurly (options) { + this.id = 0; + this.version = version; + this.configured = false; + this.config = merge({}, defaults); + if (options) this.configure(options); +} + +/** + * Inherits `Emitter`. + */ + +Emitter(Recurly.prototype); + +/** + * Configure settings. + * + * @param {Object} options + * @param {String} options.publicKey + * @param {String} [options.currency] + * @param {String} [options.api] + * @public + */ + +Recurly.prototype.configure = function configure (options) { + if (this.configured) throw errors('already-configured'); + + debug('configure'); + + if ('publicKey' in options) { + this.config.publicKey = options.publicKey; + } else { + throw errors('missing-public-key'); + } + + if ('api' in options) { + this.config.api = options.api; + } + + if ('currency' in options) { + this.config.currency = options.currency; + } + + this.configured = true; +}; + +/** + * Assembles the API endpoint. + * + * @return {String} route + * @private + */ + +Recurly.prototype.url = function url (route) { + return this.config.api + route; +}; + +/** + * Issues an API request. + * + * @param {String} route + * @param {Object} [data] + * @param {Function} done + * @throws {Error} If `configure` has not been called. + * @private + */ + +Recurly.prototype.request = function request (route, data, done) { + debug('request'); + + if (false === this.configured) { + throw errors('not-configured'); + } + + if ('function' == type(data)) { + done = data; + data = {}; + } + + var url = this.url(route); + var timeout = this.config.timeout; + + data.version = this.version; + data.key = this.config.publicKey; + + url += '?' + qs.stringify(data); + + this.cache(url, function (res, set) { + if (res) return done(null, res); + jsonp(url, { timeout: timeout }, function (err, res) { + if (err) return done(err); + if (res.error) { + done(errors('api-error', res.error)); + } else { + done(null, set(res)); + } + }); + }); +}; + +/** + * Caches an object + * + * TODO: figure out invalidation & expiry + * + * @param {String} url + * @param {Function} done + * @private + */ + +Recurly.prototype.cache = function cache (url, done) { + debug('cache'); + var stored = localStorage.getItem(url); + if (stored) { + debug('cache found ' + url); + return done(json.parse(stored)); + } else { + debug('cache set ' + url); + return done(null, set); + } + function set (obj) { + // disabled for now + // localStorage.setItem(url, json.stringify(obj)); + return obj; + } +}; + +/** + * Issues an API request to a popup window. + * + * TODO(*): configurable window name? + * TODO(*): configurable window properties? + * + * @param {String} url + * @param {Object} [data] + * @param {Function} [done] + * @throws {Error} If `configure` has not been called. + * @return {Window} + * @private + */ + +Recurly.prototype.open = function open (url, data, done) { + debug('open'); + + if (false === this.configured) { + throw errors('not-configured'); + } + + if ('function' == type(data)) { + done = data; + data = {}; + } + + data = data || {}; + data.version = this.version; + data.event = 'recurly-open-' + this.id++; + this.once(data.event, done); + + if (!/^https?:\/\//.test(url)) url = this.url(url); + url += (~url.indexOf('?') ? '&' : '?') + qs.stringify(data); + + this.relay(function () { + window.open(url, 'recurly-popup'); + }); +}; + +/** + * Relay mixin. + * + * Inspects the window for intent to relay a message, + * then attempts to send it off. closes the window once + * dispatched. + * + * @param {Function} done + * @private + */ + +Recurly.prototype.relay = function relay (done) { + var self = this; + + if (false === this.configured) { + throw errors('not-configured'); + } + + events.bind(window, 'message', function listener (event) { + var data = json.parse(event.data); + var name = data.recurly_event; + var body = data.recurly_message; + var err = body.error ? errors('api-error', body.error) : null; + events.unbind(window, 'message', listener); + if (name) self.emit(name, err, body); + if (frame) document.body.removeChild(frame); + }); + + if ('documentMode' in document) { + var frame = document.createElement('iframe'); + frame.width = frame.height = 0; + frame.src = this.url('/relay'); + frame.name = 'recurly-relay'; + frame.style.display = 'none'; + frame.onload = bind(this, done); + document.body.appendChild(frame); + } else { + done(); + } +}; + +/** + * Load the `mixins` onto Recurly.prototype. + */ + +each(mixins, function (name) { + mixin(Recurly.prototype, require('./mixins/' + name)); +}); diff --git a/lib/util/dom.js b/lib/util/dom.js new file mode 100644 index 000000000..f0a34ec67 --- /dev/null +++ b/lib/util/dom.js @@ -0,0 +1,67 @@ +/** + * dependencies + */ + +var type = require('type'); +var each = require('each'); +var map = require('map'); + +/** + * expose + */ + +module.exports = { + element: element + , value: value +}; + +/** + * Detects whether an object is an html element. + * + * @param {Mixed} node + * @return {HTMLElement|Boolean} node + */ + +function element (node) { + if (window.jQuery && node instanceof jQuery) node = node[0]; + var isElem = HTMLElement + ? node instanceof HTMLElement + : node && node.nodeType === 1; + return isElem && node; +}; + +/** + * Gets or sets the value of a given HTML form element + * + * supports text inputs, radio inputs, and selects + * + * @param {HTMLElement} node + * @return {String} value of the element + */ + +function value (node, value) { + return value !== undefined ? set(node, value) : get(node); +} + +function get (node) { + if (type(node) === 'array') node = node[0]; + var nodeType = node && node.type && node.type.toLowerCase(); + if (!nodeType) return; + else if ('options' in node) + return node.options[node.selectedIndex].value; + else if (nodeType === 'radio') + return document.querySelector('input[data-recurly=' + node.dataset.recurly + ']:checked').value; + else if ('value' in node) + return node.value; +} + +function set (nodes, value) { + if (type(nodes) !== 'array') nodes = [nodes]; + each(nodes, function (node) { + if (!node) return; + else if ('value' in node) + node.value = value; + else if ('innerText' in node) + node.innerText = value; + }); +} diff --git a/lib/util/parse-card.js b/lib/util/parse-card.js new file mode 100644 index 000000000..1026ae9fd --- /dev/null +++ b/lib/util/parse-card.js @@ -0,0 +1,11 @@ + +/** + * Removes dashes and spaces from a card number. + * + * @param {Number|String} number + * @return {String} parsed card number + */ + +module.exports = function parseCard (number) { + return number && number.toString().replace(/[-\s]/g, ''); +}; diff --git a/lib/version.js b/lib/version.js new file mode 100644 index 000000000..a4a1caa94 --- /dev/null +++ b/lib/version.js @@ -0,0 +1,6 @@ + +/** + * Current package/component version. + */ + +module.exports = '3.0.0-beta'; diff --git a/package.json b/package.json new file mode 100644 index 000000000..c90992f97 --- /dev/null +++ b/package.json @@ -0,0 +1,23 @@ +{ + "name": "recurly.js", + "description": "Zen subscription billing in the browser", + "version": "3.0.0-beta", + "license": "MIT", + "main": "recurly.js", + "repository": { + "type": "git", + "url": "git://github.com/recurly/recurly-js.git" + }, + "dependencies": {}, + "devDependencies": { + "mocha": "1.x", + "should": "2.x", + "uglify-js": "2.4.x", + "component": "0.19.x", + "express": "3.4.8", + "jade": "1.1.5", + "mocha-phantomjs": "3.3.1", + "gravy": "0.1.0", + "debug": "0.7.4" + } +} diff --git a/test/Makefile b/test/Makefile new file mode 100644 index 000000000..77c2fae88 --- /dev/null +++ b/test/Makefile @@ -0,0 +1,45 @@ + +PORT= 8989 +BIN= ../node_modules/.bin +BROWSERS ?= 'chrome, safari, firefox' +TEST= http://localhost:$(PORT) +COMPONENT= $(BIN)/component +GRAVY=$(BIN)/gravy +PHANTOMJS= $(BIN)/mocha-phantomjs \ + --setting local-to-remote-url-access=true \ + --setting-web-security=false + +build: components + @$(COMPONENT) build + +components: component.json + @$(COMPONENT) install + +server: kill + @PORT=$(PORT) node server &> /dev/null & + @sleep 1 + +test: build server + @$(PHANTOMJS) $(TEST) + -@make kill + +test-browser: build server + @open $(TEST) + +test-coverage: build server + @open $(TEST)/coverage + +test-sauce: build server + @BROWSERS=$(BROWSERS) $(GRAVY) --url $(TEST) + +clean: kill + rm -rf components build + +kill: + -@test ! -e server/pid.txt || \ + (kill `cat server/pid.txt` && \ + rm -f server/pid.txt) + +.PHONY: build +.PHONY: test-sauce test-coverage +.PHONY: test-browser test clean diff --git a/test/component.json b/test/component.json new file mode 100644 index 000000000..82b99cd2f --- /dev/null +++ b/test/component.json @@ -0,0 +1,20 @@ +{ + "name": "recurly-test", + "main": "index.js", + "scripts": [ + "index.js", + "unit/recurly.test.js", + "unit/configure.test.js", + "unit/open.test.js", + "unit/coupon.test.js" + ], + "dependencies": { + "component/bind": "*", + "component/assert": "*", + "ianstormtaylor/sinon": "*", + "yields/gravy": "*", + "component/each": "*", + "chrissrogers/noop": "*", + "component/querystring": "*" + } +} diff --git a/test/index.js b/test/index.js new file mode 100644 index 000000000..8019482f5 --- /dev/null +++ b/test/index.js @@ -0,0 +1,5 @@ + +require('./unit/recurly.test.js'); +require('./unit/configure.test.js'); +require('./unit/open.test.js'); +require('./unit/coupon.test.js'); diff --git a/test/server/coverage.jade b/test/server/coverage.jade new file mode 100644 index 000000000..e871c3f40 --- /dev/null +++ b/test/server/coverage.jade @@ -0,0 +1,19 @@ +doctype html +html + head + title recurly.js coverage + link(rel='stylesheet', href='build/build.css') + script(src='test/server/mocha.js') + script + mocha.setup({ ui: 'bdd' }) + script(src='build/build.js') + script + cov = require('coverage')('recurly'); + script(src='test/recurly.test.js') + body + #coverage + #mocha(style='display: none;') + script + mocha.run(function(){ + cov.render(); + }); diff --git a/test/server/fixtures/3d_secure/start.json b/test/server/fixtures/3d_secure/start.json new file mode 100644 index 000000000..ef47f2fd8 --- /dev/null +++ b/test/server/fixtures/3d_secure/start.json @@ -0,0 +1,4 @@ +{ + "recurly_token": "aPI-5WjHBbNGVUOEBqTUYA", + "currency": "USD" +} diff --git a/test/server/fixtures/paypal/start.json b/test/server/fixtures/paypal/start.json new file mode 100644 index 000000000..2a73b1161 --- /dev/null +++ b/test/server/fixtures/paypal/start.json @@ -0,0 +1,7 @@ +{ + "error": { + "code": "paypal_error", + "message": "Please configure a PayPal account with reference transactions in Recurly before accepting PayPal payments.", + "locale": "en-US" + } +} diff --git a/test/server/fixtures/plans/basic/coupons/coop-invalid.json b/test/server/fixtures/plans/basic/coupons/coop-invalid.json new file mode 100644 index 000000000..c27239498 --- /dev/null +++ b/test/server/fixtures/plans/basic/coupons/coop-invalid.json @@ -0,0 +1,7 @@ +{ + "error": { + "code": "not_found", + "message": "coupon is invalid", + "locale": "en-US" + } +} diff --git a/test/server/fixtures/plans/basic/coupons/coop-pct.json b/test/server/fixtures/plans/basic/coupons/coop-pct.json new file mode 100644 index 000000000..e110bbc24 --- /dev/null +++ b/test/server/fixtures/plans/basic/coupons/coop-pct.json @@ -0,0 +1,7 @@ +{ + "code": "coop-pct", + "name": "100% off!", + "discount": { + "rate": 1 + } +} diff --git a/test/server/fixtures/plans/basic/coupons/coop.json b/test/server/fixtures/plans/basic/coupons/coop.json new file mode 100644 index 000000000..c98ce445e --- /dev/null +++ b/test/server/fixtures/plans/basic/coupons/coop.json @@ -0,0 +1,7 @@ +{ + "code": "coop", + "name": "Test coupon with a long and silly name", + "discount": { + "USD": 2000 + } +} diff --git a/test/server/fixtures/plans/basic/index.json b/test/server/fixtures/plans/basic/index.json new file mode 100644 index 000000000..b1c0845ca --- /dev/null +++ b/test/server/fixtures/plans/basic/index.json @@ -0,0 +1,35 @@ +{ + "code": "basic", + "name": "Basic", + "period": { + "interval": "months", + "length": 1 + }, + "trial": { + "interval": "days", + "length": 7 + }, + "price": { + "USD": { + "setup_fee_in_cents": 200, + "unit_amount_in_cents": 1999 + } + }, + "addons": [{ + "name": "Snarf", + "code": "snarf", + "quantity": 1, + "price": { + "USD": { + "unit_amount_in_cents": 100 + } + } + }], + "accepted_card_types": [{ + "USD": { + "card_types": ["visa", "master", "american_express", "discover", "diners_club", "jcb"] + } + }], + "tax_exempt": false, + "locale": "en-US" +} diff --git a/test/server/fixtures/plans/invalid/coupons/coop.json b/test/server/fixtures/plans/invalid/coupons/coop.json new file mode 100644 index 000000000..a4db8c4dc --- /dev/null +++ b/test/server/fixtures/plans/invalid/coupons/coop.json @@ -0,0 +1,7 @@ +{ + "error": { + "code": "not_found", + "message": "Couldn't find Plan with plan_code = invalid", + "locale": "en-US" + } +} diff --git a/test/server/fixtures/plans/invalid/index.json b/test/server/fixtures/plans/invalid/index.json new file mode 100644 index 000000000..a4db8c4dc --- /dev/null +++ b/test/server/fixtures/plans/invalid/index.json @@ -0,0 +1,7 @@ +{ + "error": { + "code": "not_found", + "message": "Couldn't find Plan with plan_code = invalid", + "locale": "en-US" + } +} diff --git a/test/server/fixtures/tax/index.js b/test/server/fixtures/tax/index.js new file mode 100644 index 000000000..5008462d6 --- /dev/null +++ b/test/server/fixtures/tax/index.js @@ -0,0 +1,51 @@ + +/** + * postal code to match for US sales tax + */ + +var USST_POSTAL_CODE = '94107'; + + +/** + * country code to match for VAT + */ + +var VAT_COUNTRY = 'DE'; + +/** + * US sales tax response + * - country: 'US' + * - postal_code: USST_POSTAL_CODE + * + * VAT response + * - country: VAT_COUNTRY + * + * No tax response + * - all other requests + */ + +module.exports = function tax (req, res) { + if (req.query.country === 'US' && req.query.postal_code === USST_POSTAL_CODE) return usst; + if (req.query.country === VAT_COUNTRY) return vat; + return none; +}; + +var usst = { + "taxes": [{ + "type": "usst", + "rate": "0.0875" + }], + "locale": "en-US" +}; + +var vat = { + "taxes": [{ + "type": "vat", + "rate": "0.015" + }], + "locale": "en-US" +}; + +var none = { + "locale": "en-US" +}; diff --git a/test/server/fixtures/token/index.js b/test/server/fixtures/token/index.js new file mode 100644 index 000000000..bd4cdf040 --- /dev/null +++ b/test/server/fixtures/token/index.js @@ -0,0 +1,54 @@ + +/** + * FIXME: need to get more decline messages: cvv, invalid fields, etc + * This is contingent upon tokenizing with non-test cards + */ + +/** + * Recurly standard magic decline number + */ + +var DECLINE_CARD = '4000000000000002'; + +module.exports = function token (req, res) { + if (req.query.number === DECLINE_CARD) return decline; + else if (!req.query.first_name) return blankParam; + else return ok; +}; + +/** + * successful tokenization + */ + +var ok = { + "amount_in_cents": 0, + "currency": "USD", + "token": "7QF5CSJ2n-6CXX1k15FtYA" +}; + +/** + * 'first_name' is blank + */ + +var blankParam = { + "error": { + "code": "missing_parameter", + "message": "'first_name' is blank", + "locale": "en-US", + "fields": ["first_name"] + } +}; + +/** + * card decline error. could be due to invalid nubmer, cvv, exp date + */ + +var decline = { + "error": { + "code": "declined", + "message": "Your card was declined. In order to resolve the issue, you will need to contact your bank.", + "fields": ["number"], + "locale": "en-US" + } +}; + diff --git a/test/server/index.jade b/test/server/index.jade new file mode 100644 index 000000000..94e722d1a --- /dev/null +++ b/test/server/index.jade @@ -0,0 +1,20 @@ +doctype html +html + head + title recurly.js tests + link(rel='stylesheet', href='/test/server/mocha.css') + script(src='/recurly.js') + script(src='/test/server/mocha.js') + script. + mocha.setup({ ui: 'bdd' }) + script(src='/test/build/build.js') + script. + require('recurly-test'); + body + #mocha + script. + if (window.mochaPhantomJS) { + mochaPhantomJS.run(); + } else { + require('gravy')(mocha.run()); + } diff --git a/test/server/index.js b/test/server/index.js new file mode 100644 index 000000000..f4d9deb55 --- /dev/null +++ b/test/server/index.js @@ -0,0 +1,83 @@ + +/*! + * Module dependencies. + */ + +var fs = require('fs'); +var path = require('path'); +var express = require('express'); +var app = module.exports = express(); + +/** + * Settings. + */ + +app.set('views', __dirname); +app.set('view engine', 'jade'); +app.set('view options', { debug: true }) +app.set('port', process.env.PORT || 8989); +app.set('jsonp callback name', 'callback'); + +/** + * Locals. + */ + +app.locals.pretty = true; + +/** + * Middleware. + */ + +app.use(express.static(path.resolve(__dirname + '/../..'))); + +/** + * Fixtures. + */ + +app.get('/plans/:plan_code', jsonp); +app.get('/plans/:plan_code/coupons/:coupon_code', jsonp); +app.get('/token', jsonp); +app.get('/tax', jsonp); +app.get('/3d_secure/start', postMessage); +app.get('/paypal/start', postMessage); +app.get('/relay', render('relay')); +app.get('*', render('index')); + +/** + * Listen. + */ + +app.listen(app.get('port'), function () { + fs.writeFileSync(__dirname + '/pid.txt', process.pid, 'utf-8'); +}); + +/** + * Utility functions. + */ + +function render (view) { + return function (req, res) { + res.render(view); + }; +} + +function jsonp (req, res) { + res.jsonp(fixture(req, res)); +} + +function postMessage (req, res) { + res.render('post-message', { + message: { + recurly_event: req.query.event + , recurly_message: fixture(req, res) + } + }); +} + +function fixture (req, res) { + var fixture = require('./fixtures' + req.path); + return 'function' === typeof fixture + ? fixture(req, res) + : fixture; +} + diff --git a/test/server/mocha.css b/test/server/mocha.css new file mode 100644 index 000000000..274b97762 --- /dev/null +++ b/test/server/mocha.css @@ -0,0 +1,260 @@ +@charset "utf-8"; + +body { + margin:0; +} + +#mocha { + font: 20px/1.5 "Helvetica Neue", Helvetica, Arial, sans-serif; + margin: 60px 50px; +} + +#mocha ul, #mocha li { + margin: 0; + padding: 0; +} + +#mocha ul { + list-style: none; +} + +#mocha h1, #mocha h2 { + margin: 0; +} + +#mocha h1 { + margin-top: 15px; + font-size: 1em; + font-weight: 200; +} + +#mocha h1 a { + text-decoration: none; + color: inherit; +} + +#mocha h1 a:hover { + text-decoration: underline; +} + +#mocha .suite .suite h1 { + margin-top: 0; + font-size: .8em; +} + +#mocha .hidden { + display: none; +} + +#mocha h2 { + font-size: 12px; + font-weight: normal; + cursor: pointer; +} + +#mocha .suite { + margin-left: 15px; +} + +#mocha .test { + margin-left: 15px; + overflow: hidden; +} + +#mocha .test.pending:hover h2::after { + content: '(pending)'; + font-family: arial, sans-serif; +} + +#mocha .test.pass.medium .duration { + background: #C09853; +} + +#mocha .test.pass.slow .duration { + background: #B94A48; +} + +#mocha .test.pass::before { + content: '✓'; + font-size: 12px; + display: block; + float: left; + margin-right: 5px; + color: #00d6b2; +} + +#mocha .test.pass .duration { + font-size: 9px; + margin-left: 5px; + padding: 2px 5px; + color: white; + -webkit-box-shadow: inset 0 1px 1px rgba(0,0,0,.2); + -moz-box-shadow: inset 0 1px 1px rgba(0,0,0,.2); + box-shadow: inset 0 1px 1px rgba(0,0,0,.2); + -webkit-border-radius: 5px; + -moz-border-radius: 5px; + -ms-border-radius: 5px; + -o-border-radius: 5px; + border-radius: 5px; +} + +#mocha .test.pass.fast .duration { + display: none; +} + +#mocha .test.pending { + color: #0b97c4; +} + +#mocha .test.pending::before { + content: '◦'; + color: #0b97c4; +} + +#mocha .test.fail { + color: #c00; +} + +#mocha .test.fail pre { + color: black; +} + +#mocha .test.fail::before { + content: '✖'; + font-size: 12px; + display: block; + float: left; + margin-right: 5px; + color: #c00; +} + +#mocha .test pre.error { + color: #c00; + max-height: 300px; + overflow: auto; +} + +#mocha .test pre { + display: block; + float: left; + clear: left; + font: 12px/1.5 monaco, monospace; + margin: 5px; + padding: 15px; + border: 1px solid #eee; + border-bottom-color: #ddd; + -webkit-border-radius: 3px; + -webkit-box-shadow: 0 1px 3px #eee; + -moz-border-radius: 3px; + -moz-box-shadow: 0 1px 3px #eee; + border-radius: 3px; +} + +#mocha .test h2 { + position: relative; +} + +#mocha .test a.replay { + position: absolute; + top: 3px; + right: 0; + text-decoration: none; + vertical-align: middle; + display: block; + width: 15px; + height: 15px; + line-height: 15px; + text-align: center; + background: #eee; + font-size: 15px; + -moz-border-radius: 15px; + border-radius: 15px; + -webkit-transition: opacity 200ms; + -moz-transition: opacity 200ms; + transition: opacity 200ms; + opacity: 0.3; + color: #888; +} + +#mocha .test:hover a.replay { + opacity: 1; +} + +#mocha-report.pass .test.fail { + display: none; +} + +#mocha-report.fail .test.pass { + display: none; +} + +#mocha-report.pending .test.pass, +#mocha-report.pending .test.fail { + display: none; +} +#mocha-report.pending .test.pass.pending { + display: block; +} + +#mocha-error { + color: #c00; + font-size: 1.5em; + font-weight: 100; + letter-spacing: 1px; +} + +#mocha-stats { + position: fixed; + top: 15px; + right: 10px; + font-size: 12px; + margin: 0; + color: #888; + z-index: 1; +} + +#mocha-stats .progress { + float: right; + padding-top: 0; +} + +#mocha-stats em { + color: black; +} + +#mocha-stats a { + text-decoration: none; + color: inherit; +} + +#mocha-stats a:hover { + border-bottom: 1px solid #eee; +} + +#mocha-stats li { + display: inline-block; + margin: 0 5px; + list-style: none; + padding-top: 11px; +} + +#mocha-stats canvas { + width: 40px; + height: 40px; +} + +#mocha code .comment { color: #ddd } +#mocha code .init { color: #2F6FAD } +#mocha code .string { color: #5890AD } +#mocha code .keyword { color: #8A6343 } +#mocha code .number { color: #2F6FAD } + +@media screen and (max-device-width: 480px) { + #mocha { + margin: 60px 0px; + } + + #mocha #stats { + position: absolute; + } +} diff --git a/test/server/mocha.js b/test/server/mocha.js new file mode 100644 index 000000000..d5cb7f105 --- /dev/null +++ b/test/server/mocha.js @@ -0,0 +1,5547 @@ +;(function(){ + +// CommonJS require() + +function require(p){ + var path = require.resolve(p) + , mod = require.modules[path]; + if (!mod) throw new Error('failed to require "' + p + '"'); + if (!mod.exports) { + mod.exports = {}; + mod.call(mod.exports, mod, mod.exports, require.relative(path)); + } + return mod.exports; + } + +require.modules = {}; + +require.resolve = function (path){ + var orig = path + , reg = path + '.js' + , index = path + '/index.js'; + return require.modules[reg] && reg + || require.modules[index] && index + || orig; + }; + +require.register = function (path, fn){ + require.modules[path] = fn; + }; + +require.relative = function (parent) { + return function(p){ + if ('.' != p.charAt(0)) return require(p); + + var path = parent.split('/') + , segs = p.split('/'); + path.pop(); + + for (var i = 0; i < segs.length; i++) { + var seg = segs[i]; + if ('..' == seg) path.pop(); + else if ('.' != seg) path.push(seg); + } + + return require(path.join('/')); + }; + }; + + +require.register("browser/debug.js", function(module, exports, require){ + +module.exports = function(type){ + return function(){ + } +}; + +}); // module: browser/debug.js + +require.register("browser/diff.js", function(module, exports, require){ +/* See LICENSE file for terms of use */ + +/* + * Text diff implementation. + * + * This library supports the following APIS: + * JsDiff.diffChars: Character by character diff + * JsDiff.diffWords: Word (as defined by \b regex) diff which ignores whitespace + * JsDiff.diffLines: Line based diff + * + * JsDiff.diffCss: Diff targeted at CSS content + * + * These methods are based on the implementation proposed in + * "An O(ND) Difference Algorithm and its Variations" (Myers, 1986). + * http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.4.6927 + */ +var JsDiff = (function() { + /*jshint maxparams: 5*/ + function clonePath(path) { + return { newPos: path.newPos, components: path.components.slice(0) }; + } + function removeEmpty(array) { + var ret = []; + for (var i = 0; i < array.length; i++) { + if (array[i]) { + ret.push(array[i]); + } + } + return ret; + } + function escapeHTML(s) { + var n = s; + n = n.replace(/&/g, '&'); + n = n.replace(//g, '>'); + n = n.replace(/"/g, '"'); + + return n; + } + + var Diff = function(ignoreWhitespace) { + this.ignoreWhitespace = ignoreWhitespace; + }; + Diff.prototype = { + diff: function(oldString, newString) { + // Handle the identity case (this is due to unrolling editLength == 0 + if (newString === oldString) { + return [{ value: newString }]; + } + if (!newString) { + return [{ value: oldString, removed: true }]; + } + if (!oldString) { + return [{ value: newString, added: true }]; + } + + newString = this.tokenize(newString); + oldString = this.tokenize(oldString); + + var newLen = newString.length, oldLen = oldString.length; + var maxEditLength = newLen + oldLen; + var bestPath = [{ newPos: -1, components: [] }]; + + // Seed editLength = 0 + var oldPos = this.extractCommon(bestPath[0], newString, oldString, 0); + if (bestPath[0].newPos+1 >= newLen && oldPos+1 >= oldLen) { + return bestPath[0].components; + } + + for (var editLength = 1; editLength <= maxEditLength; editLength++) { + for (var diagonalPath = -1*editLength; diagonalPath <= editLength; diagonalPath+=2) { + var basePath; + var addPath = bestPath[diagonalPath-1], + removePath = bestPath[diagonalPath+1]; + oldPos = (removePath ? removePath.newPos : 0) - diagonalPath; + if (addPath) { + // No one else is going to attempt to use this value, clear it + bestPath[diagonalPath-1] = undefined; + } + + var canAdd = addPath && addPath.newPos+1 < newLen; + var canRemove = removePath && 0 <= oldPos && oldPos < oldLen; + if (!canAdd && !canRemove) { + bestPath[diagonalPath] = undefined; + continue; + } + + // Select the diagonal that we want to branch from. We select the prior + // path whose position in the new string is the farthest from the origin + // and does not pass the bounds of the diff graph + if (!canAdd || (canRemove && addPath.newPos < removePath.newPos)) { + basePath = clonePath(removePath); + this.pushComponent(basePath.components, oldString[oldPos], undefined, true); + } else { + basePath = clonePath(addPath); + basePath.newPos++; + this.pushComponent(basePath.components, newString[basePath.newPos], true, undefined); + } + + var oldPos = this.extractCommon(basePath, newString, oldString, diagonalPath); + + if (basePath.newPos+1 >= newLen && oldPos+1 >= oldLen) { + return basePath.components; + } else { + bestPath[diagonalPath] = basePath; + } + } + } + }, + + pushComponent: function(components, value, added, removed) { + var last = components[components.length-1]; + if (last && last.added === added && last.removed === removed) { + // We need to clone here as the component clone operation is just + // as shallow array clone + components[components.length-1] = + {value: this.join(last.value, value), added: added, removed: removed }; + } else { + components.push({value: value, added: added, removed: removed }); + } + }, + extractCommon: function(basePath, newString, oldString, diagonalPath) { + var newLen = newString.length, + oldLen = oldString.length, + newPos = basePath.newPos, + oldPos = newPos - diagonalPath; + while (newPos+1 < newLen && oldPos+1 < oldLen && this.equals(newString[newPos+1], oldString[oldPos+1])) { + newPos++; + oldPos++; + + this.pushComponent(basePath.components, newString[newPos], undefined, undefined); + } + basePath.newPos = newPos; + return oldPos; + }, + + equals: function(left, right) { + var reWhitespace = /\S/; + if (this.ignoreWhitespace && !reWhitespace.test(left) && !reWhitespace.test(right)) { + return true; + } else { + return left === right; + } + }, + join: function(left, right) { + return left + right; + }, + tokenize: function(value) { + return value; + } + }; + + var CharDiff = new Diff(); + + var WordDiff = new Diff(true); + var WordWithSpaceDiff = new Diff(); + WordDiff.tokenize = WordWithSpaceDiff.tokenize = function(value) { + return removeEmpty(value.split(/(\s+|\b)/)); + }; + + var CssDiff = new Diff(true); + CssDiff.tokenize = function(value) { + return removeEmpty(value.split(/([{}:;,]|\s+)/)); + }; + + var LineDiff = new Diff(); + LineDiff.tokenize = function(value) { + return value.split(/^/m); + }; + + return { + Diff: Diff, + + diffChars: function(oldStr, newStr) { return CharDiff.diff(oldStr, newStr); }, + diffWords: function(oldStr, newStr) { return WordDiff.diff(oldStr, newStr); }, + diffWordsWithSpace: function(oldStr, newStr) { return WordWithSpaceDiff.diff(oldStr, newStr); }, + diffLines: function(oldStr, newStr) { return LineDiff.diff(oldStr, newStr); }, + + diffCss: function(oldStr, newStr) { return CssDiff.diff(oldStr, newStr); }, + + createPatch: function(fileName, oldStr, newStr, oldHeader, newHeader) { + var ret = []; + + ret.push('Index: ' + fileName); + ret.push('==================================================================='); + ret.push('--- ' + fileName + (typeof oldHeader === 'undefined' ? '' : '\t' + oldHeader)); + ret.push('+++ ' + fileName + (typeof newHeader === 'undefined' ? '' : '\t' + newHeader)); + + var diff = LineDiff.diff(oldStr, newStr); + if (!diff[diff.length-1].value) { + diff.pop(); // Remove trailing newline add + } + diff.push({value: '', lines: []}); // Append an empty value to make cleanup easier + + function contextLines(lines) { + return lines.map(function(entry) { return ' ' + entry; }); + } + function eofNL(curRange, i, current) { + var last = diff[diff.length-2], + isLast = i === diff.length-2, + isLastOfType = i === diff.length-3 && (current.added !== last.added || current.removed !== last.removed); + + // Figure out if this is the last line for the given file and missing NL + if (!/\n$/.test(current.value) && (isLast || isLastOfType)) { + curRange.push('\\ No newline at end of file'); + } + } + + var oldRangeStart = 0, newRangeStart = 0, curRange = [], + oldLine = 1, newLine = 1; + for (var i = 0; i < diff.length; i++) { + var current = diff[i], + lines = current.lines || current.value.replace(/\n$/, '').split('\n'); + current.lines = lines; + + if (current.added || current.removed) { + if (!oldRangeStart) { + var prev = diff[i-1]; + oldRangeStart = oldLine; + newRangeStart = newLine; + + if (prev) { + curRange = contextLines(prev.lines.slice(-4)); + oldRangeStart -= curRange.length; + newRangeStart -= curRange.length; + } + } + curRange.push.apply(curRange, lines.map(function(entry) { return (current.added?'+':'-') + entry; })); + eofNL(curRange, i, current); + + if (current.added) { + newLine += lines.length; + } else { + oldLine += lines.length; + } + } else { + if (oldRangeStart) { + // Close out any changes that have been output (or join overlapping) + if (lines.length <= 8 && i < diff.length-2) { + // Overlapping + curRange.push.apply(curRange, contextLines(lines)); + } else { + // end the range and output + var contextSize = Math.min(lines.length, 4); + ret.push( + '@@ -' + oldRangeStart + ',' + (oldLine-oldRangeStart+contextSize) + + ' +' + newRangeStart + ',' + (newLine-newRangeStart+contextSize) + + ' @@'); + ret.push.apply(ret, curRange); + ret.push.apply(ret, contextLines(lines.slice(0, contextSize))); + if (lines.length <= 4) { + eofNL(ret, i, current); + } + + oldRangeStart = 0; newRangeStart = 0; curRange = []; + } + } + oldLine += lines.length; + newLine += lines.length; + } + } + + return ret.join('\n') + '\n'; + }, + + applyPatch: function(oldStr, uniDiff) { + var diffstr = uniDiff.split('\n'); + var diff = []; + var remEOFNL = false, + addEOFNL = false; + + for (var i = (diffstr[0][0]==='I'?4:0); i < diffstr.length; i++) { + if(diffstr[i][0] === '@') { + var meh = diffstr[i].split(/@@ -(\d+),(\d+) \+(\d+),(\d+) @@/); + diff.unshift({ + start:meh[3], + oldlength:meh[2], + oldlines:[], + newlength:meh[4], + newlines:[] + }); + } else if(diffstr[i][0] === '+') { + diff[0].newlines.push(diffstr[i].substr(1)); + } else if(diffstr[i][0] === '-') { + diff[0].oldlines.push(diffstr[i].substr(1)); + } else if(diffstr[i][0] === ' ') { + diff[0].newlines.push(diffstr[i].substr(1)); + diff[0].oldlines.push(diffstr[i].substr(1)); + } else if(diffstr[i][0] === '\\') { + if (diffstr[i-1][0] === '+') { + remEOFNL = true; + } else if(diffstr[i-1][0] === '-') { + addEOFNL = true; + } + } + } + + var str = oldStr.split('\n'); + for (var i = diff.length - 1; i >= 0; i--) { + var d = diff[i]; + for (var j = 0; j < d.oldlength; j++) { + if(str[d.start-1+j] !== d.oldlines[j]) { + return false; + } + } + Array.prototype.splice.apply(str,[d.start-1,+d.oldlength].concat(d.newlines)); + } + + if (remEOFNL) { + while (!str[str.length-1]) { + str.pop(); + } + } else if (addEOFNL) { + str.push(''); + } + return str.join('\n'); + }, + + convertChangesToXML: function(changes){ + var ret = []; + for ( var i = 0; i < changes.length; i++) { + var change = changes[i]; + if (change.added) { + ret.push(''); + } else if (change.removed) { + ret.push(''); + } + + ret.push(escapeHTML(change.value)); + + if (change.added) { + ret.push(''); + } else if (change.removed) { + ret.push(''); + } + } + return ret.join(''); + }, + + // See: http://code.google.com/p/google-diff-match-patch/wiki/API + convertChangesToDMP: function(changes){ + var ret = [], change; + for ( var i = 0; i < changes.length; i++) { + change = changes[i]; + ret.push([(change.added ? 1 : change.removed ? -1 : 0), change.value]); + } + return ret; + } + }; +})(); + +if (typeof module !== 'undefined') { + module.exports = JsDiff; +} + +}); // module: browser/diff.js + +require.register("browser/events.js", function(module, exports, require){ + +/** + * Module exports. + */ + +exports.EventEmitter = EventEmitter; + +/** + * Check if `obj` is an array. + */ + +function isArray(obj) { + return '[object Array]' == {}.toString.call(obj); +} + +/** + * Event emitter constructor. + * + * @api public + */ + +function EventEmitter(){}; + +/** + * Adds a listener. + * + * @api public + */ + +EventEmitter.prototype.on = function (name, fn) { + if (!this.$events) { + this.$events = {}; + } + + if (!this.$events[name]) { + this.$events[name] = fn; + } else if (isArray(this.$events[name])) { + this.$events[name].push(fn); + } else { + this.$events[name] = [this.$events[name], fn]; + } + + return this; +}; + +EventEmitter.prototype.addListener = EventEmitter.prototype.on; + +/** + * Adds a volatile listener. + * + * @api public + */ + +EventEmitter.prototype.once = function (name, fn) { + var self = this; + + function on () { + self.removeListener(name, on); + fn.apply(this, arguments); + }; + + on.listener = fn; + this.on(name, on); + + return this; +}; + +/** + * Removes a listener. + * + * @api public + */ + +EventEmitter.prototype.removeListener = function (name, fn) { + if (this.$events && this.$events[name]) { + var list = this.$events[name]; + + if (isArray(list)) { + var pos = -1; + + for (var i = 0, l = list.length; i < l; i++) { + if (list[i] === fn || (list[i].listener && list[i].listener === fn)) { + pos = i; + break; + } + } + + if (pos < 0) { + return this; + } + + list.splice(pos, 1); + + if (!list.length) { + delete this.$events[name]; + } + } else if (list === fn || (list.listener && list.listener === fn)) { + delete this.$events[name]; + } + } + + return this; +}; + +/** + * Removes all listeners for an event. + * + * @api public + */ + +EventEmitter.prototype.removeAllListeners = function (name) { + if (name === undefined) { + this.$events = {}; + return this; + } + + if (this.$events && this.$events[name]) { + this.$events[name] = null; + } + + return this; +}; + +/** + * Gets all listeners for a certain event. + * + * @api public + */ + +EventEmitter.prototype.listeners = function (name) { + if (!this.$events) { + this.$events = {}; + } + + if (!this.$events[name]) { + this.$events[name] = []; + } + + if (!isArray(this.$events[name])) { + this.$events[name] = [this.$events[name]]; + } + + return this.$events[name]; +}; + +/** + * Emits an event. + * + * @api public + */ + +EventEmitter.prototype.emit = function (name) { + if (!this.$events) { + return false; + } + + var handler = this.$events[name]; + + if (!handler) { + return false; + } + + var args = [].slice.call(arguments, 1); + + if ('function' == typeof handler) { + handler.apply(this, args); + } else if (isArray(handler)) { + var listeners = handler.slice(); + + for (var i = 0, l = listeners.length; i < l; i++) { + listeners[i].apply(this, args); + } + } else { + return false; + } + + return true; +}; +}); // module: browser/events.js + +require.register("browser/fs.js", function(module, exports, require){ + +}); // module: browser/fs.js + +require.register("browser/path.js", function(module, exports, require){ + +}); // module: browser/path.js + +require.register("browser/progress.js", function(module, exports, require){ + +/** + * Expose `Progress`. + */ + +module.exports = Progress; + +/** + * Initialize a new `Progress` indicator. + */ + +function Progress() { + this.percent = 0; + this.size(0); + this.fontSize(11); + this.font('helvetica, arial, sans-serif'); +} + +/** + * Set progress size to `n`. + * + * @param {Number} n + * @return {Progress} for chaining + * @api public + */ + +Progress.prototype.size = function(n){ + this._size = n; + return this; +}; + +/** + * Set text to `str`. + * + * @param {String} str + * @return {Progress} for chaining + * @api public + */ + +Progress.prototype.text = function(str){ + this._text = str; + return this; +}; + +/** + * Set font size to `n`. + * + * @param {Number} n + * @return {Progress} for chaining + * @api public + */ + +Progress.prototype.fontSize = function(n){ + this._fontSize = n; + return this; +}; + +/** + * Set font `family`. + * + * @param {String} family + * @return {Progress} for chaining + */ + +Progress.prototype.font = function(family){ + this._font = family; + return this; +}; + +/** + * Update percentage to `n`. + * + * @param {Number} n + * @return {Progress} for chaining + */ + +Progress.prototype.update = function(n){ + this.percent = n; + return this; +}; + +/** + * Draw on `ctx`. + * + * @param {CanvasRenderingContext2d} ctx + * @return {Progress} for chaining + */ + +Progress.prototype.draw = function(ctx){ + var percent = Math.min(this.percent, 100) + , size = this._size + , half = size / 2 + , x = half + , y = half + , rad = half - 1 + , fontSize = this._fontSize; + + ctx.font = fontSize + 'px ' + this._font; + + var angle = Math.PI * 2 * (percent / 100); + ctx.clearRect(0, 0, size, size); + + // outer circle + ctx.strokeStyle = '#9f9f9f'; + ctx.beginPath(); + ctx.arc(x, y, rad, 0, angle, false); + ctx.stroke(); + + // inner circle + ctx.strokeStyle = '#eee'; + ctx.beginPath(); + ctx.arc(x, y, rad - 1, 0, angle, true); + ctx.stroke(); + + // text + var text = this._text || (percent | 0) + '%' + , w = ctx.measureText(text).width; + + ctx.fillText( + text + , x - w / 2 + 1 + , y + fontSize / 2 - 1); + + return this; +}; + +}); // module: browser/progress.js + +require.register("browser/tty.js", function(module, exports, require){ + +exports.isatty = function(){ + return true; +}; + +exports.getWindowSize = function(){ + if ('innerHeight' in global) { + return [global.innerHeight, global.innerWidth]; + } else { + // In a Web Worker, the DOM Window is not available. + return [640, 480]; + } +}; + +}); // module: browser/tty.js + +require.register("context.js", function(module, exports, require){ + +/** + * Expose `Context`. + */ + +module.exports = Context; + +/** + * Initialize a new `Context`. + * + * @api private + */ + +function Context(){} + +/** + * Set or get the context `Runnable` to `runnable`. + * + * @param {Runnable} runnable + * @return {Context} + * @api private + */ + +Context.prototype.runnable = function(runnable){ + if (0 == arguments.length) return this._runnable; + this.test = this._runnable = runnable; + return this; +}; + +/** + * Set test timeout `ms`. + * + * @param {Number} ms + * @return {Context} self + * @api private + */ + +Context.prototype.timeout = function(ms){ + this.runnable().timeout(ms); + return this; +}; + +/** + * Set test slowness threshold `ms`. + * + * @param {Number} ms + * @return {Context} self + * @api private + */ + +Context.prototype.slow = function(ms){ + this.runnable().slow(ms); + return this; +}; + +/** + * Inspect the context void of `._runnable`. + * + * @return {String} + * @api private + */ + +Context.prototype.inspect = function(){ + return JSON.stringify(this, function(key, val){ + if ('_runnable' == key) return; + if ('test' == key) return; + return val; + }, 2); +}; + +}); // module: context.js + +require.register("hook.js", function(module, exports, require){ + +/** + * Module dependencies. + */ + +var Runnable = require('./runnable'); + +/** + * Expose `Hook`. + */ + +module.exports = Hook; + +/** + * Initialize a new `Hook` with the given `title` and callback `fn`. + * + * @param {String} title + * @param {Function} fn + * @api private + */ + +function Hook(title, fn) { + Runnable.call(this, title, fn); + this.type = 'hook'; +} + +/** + * Inherit from `Runnable.prototype`. + */ + +function F(){}; +F.prototype = Runnable.prototype; +Hook.prototype = new F; +Hook.prototype.constructor = Hook; + + +/** + * Get or set the test `err`. + * + * @param {Error} err + * @return {Error} + * @api public + */ + +Hook.prototype.error = function(err){ + if (0 == arguments.length) { + var err = this._error; + this._error = null; + return err; + } + + this._error = err; +}; + +}); // module: hook.js + +require.register("interfaces/bdd.js", function(module, exports, require){ + +/** + * Module dependencies. + */ + +var Suite = require('../suite') + , Test = require('../test') + , utils = require('../utils'); + +/** + * BDD-style interface: + * + * describe('Array', function(){ + * describe('#indexOf()', function(){ + * it('should return -1 when not present', function(){ + * + * }); + * + * it('should return the index when present', function(){ + * + * }); + * }); + * }); + * + */ + +module.exports = function(suite){ + var suites = [suite]; + + suite.on('pre-require', function(context, file, mocha){ + + /** + * Execute before running tests. + */ + + context.before = function(fn){ + suites[0].beforeAll(fn); + }; + + /** + * Execute after running tests. + */ + + context.after = function(fn){ + suites[0].afterAll(fn); + }; + + /** + * Execute before each test case. + */ + + context.beforeEach = function(fn){ + suites[0].beforeEach(fn); + }; + + /** + * Execute after each test case. + */ + + context.afterEach = function(fn){ + suites[0].afterEach(fn); + }; + + /** + * Describe a "suite" with the given `title` + * and callback `fn` containing nested suites + * and/or tests. + */ + + context.describe = context.context = function(title, fn){ + var suite = Suite.create(suites[0], title); + suites.unshift(suite); + fn.call(suite); + suites.shift(); + return suite; + }; + + /** + * Pending describe. + */ + + context.xdescribe = + context.xcontext = + context.describe.skip = function(title, fn){ + var suite = Suite.create(suites[0], title); + suite.pending = true; + suites.unshift(suite); + fn.call(suite); + suites.shift(); + }; + + /** + * Exclusive suite. + */ + + context.describe.only = function(title, fn){ + var suite = context.describe(title, fn); + mocha.grep(suite.fullTitle()); + return suite; + }; + + /** + * Describe a specification or test-case + * with the given `title` and callback `fn` + * acting as a thunk. + */ + + context.it = context.specify = function(title, fn){ + var suite = suites[0]; + if (suite.pending) var fn = null; + var test = new Test(title, fn); + suite.addTest(test); + return test; + }; + + /** + * Exclusive test-case. + */ + + context.it.only = function(title, fn){ + var test = context.it(title, fn); + var reString = '^' + utils.escapeRegexp(test.fullTitle()) + '$'; + mocha.grep(new RegExp(reString)); + return test; + }; + + /** + * Pending test case. + */ + + context.xit = + context.xspecify = + context.it.skip = function(title){ + context.it(title); + }; + }); +}; + +}); // module: interfaces/bdd.js + +require.register("interfaces/exports.js", function(module, exports, require){ + +/** + * Module dependencies. + */ + +var Suite = require('../suite') + , Test = require('../test'); + +/** + * TDD-style interface: + * + * exports.Array = { + * '#indexOf()': { + * 'should return -1 when the value is not present': function(){ + * + * }, + * + * 'should return the correct index when the value is present': function(){ + * + * } + * } + * }; + * + */ + +module.exports = function(suite){ + var suites = [suite]; + + suite.on('require', visit); + + function visit(obj) { + var suite; + for (var key in obj) { + if ('function' == typeof obj[key]) { + var fn = obj[key]; + switch (key) { + case 'before': + suites[0].beforeAll(fn); + break; + case 'after': + suites[0].afterAll(fn); + break; + case 'beforeEach': + suites[0].beforeEach(fn); + break; + case 'afterEach': + suites[0].afterEach(fn); + break; + default: + suites[0].addTest(new Test(key, fn)); + } + } else { + var suite = Suite.create(suites[0], key); + suites.unshift(suite); + visit(obj[key]); + suites.shift(); + } + } + } +}; + +}); // module: interfaces/exports.js + +require.register("interfaces/index.js", function(module, exports, require){ + +exports.bdd = require('./bdd'); +exports.tdd = require('./tdd'); +exports.qunit = require('./qunit'); +exports.exports = require('./exports'); + +}); // module: interfaces/index.js + +require.register("interfaces/qunit.js", function(module, exports, require){ + +/** + * Module dependencies. + */ + +var Suite = require('../suite') + , Test = require('../test') + , utils = require('../utils'); + +/** + * QUnit-style interface: + * + * suite('Array'); + * + * test('#length', function(){ + * var arr = [1,2,3]; + * ok(arr.length == 3); + * }); + * + * test('#indexOf()', function(){ + * var arr = [1,2,3]; + * ok(arr.indexOf(1) == 0); + * ok(arr.indexOf(2) == 1); + * ok(arr.indexOf(3) == 2); + * }); + * + * suite('String'); + * + * test('#length', function(){ + * ok('foo'.length == 3); + * }); + * + */ + +module.exports = function(suite){ + var suites = [suite]; + + suite.on('pre-require', function(context, file, mocha){ + + /** + * Execute before running tests. + */ + + context.before = function(fn){ + suites[0].beforeAll(fn); + }; + + /** + * Execute after running tests. + */ + + context.after = function(fn){ + suites[0].afterAll(fn); + }; + + /** + * Execute before each test case. + */ + + context.beforeEach = function(fn){ + suites[0].beforeEach(fn); + }; + + /** + * Execute after each test case. + */ + + context.afterEach = function(fn){ + suites[0].afterEach(fn); + }; + + /** + * Describe a "suite" with the given `title`. + */ + + context.suite = function(title){ + if (suites.length > 1) suites.shift(); + var suite = Suite.create(suites[0], title); + suites.unshift(suite); + return suite; + }; + + /** + * Exclusive test-case. + */ + + context.suite.only = function(title, fn){ + var suite = context.suite(title, fn); + mocha.grep(suite.fullTitle()); + }; + + /** + * Describe a specification or test-case + * with the given `title` and callback `fn` + * acting as a thunk. + */ + + context.test = function(title, fn){ + var test = new Test(title, fn); + suites[0].addTest(test); + return test; + }; + + /** + * Exclusive test-case. + */ + + context.test.only = function(title, fn){ + var test = context.test(title, fn); + var reString = '^' + utils.escapeRegexp(test.fullTitle()) + '$'; + mocha.grep(new RegExp(reString)); + }; + + /** + * Pending test case. + */ + + context.test.skip = function(title){ + context.test(title); + }; + }); +}; + +}); // module: interfaces/qunit.js + +require.register("interfaces/tdd.js", function(module, exports, require){ + +/** + * Module dependencies. + */ + +var Suite = require('../suite') + , Test = require('../test') + , utils = require('../utils');; + +/** + * TDD-style interface: + * + * suite('Array', function(){ + * suite('#indexOf()', function(){ + * suiteSetup(function(){ + * + * }); + * + * test('should return -1 when not present', function(){ + * + * }); + * + * test('should return the index when present', function(){ + * + * }); + * + * suiteTeardown(function(){ + * + * }); + * }); + * }); + * + */ + +module.exports = function(suite){ + var suites = [suite]; + + suite.on('pre-require', function(context, file, mocha){ + + /** + * Execute before each test case. + */ + + context.setup = function(fn){ + suites[0].beforeEach(fn); + }; + + /** + * Execute after each test case. + */ + + context.teardown = function(fn){ + suites[0].afterEach(fn); + }; + + /** + * Execute before the suite. + */ + + context.suiteSetup = function(fn){ + suites[0].beforeAll(fn); + }; + + /** + * Execute after the suite. + */ + + context.suiteTeardown = function(fn){ + suites[0].afterAll(fn); + }; + + /** + * Describe a "suite" with the given `title` + * and callback `fn` containing nested suites + * and/or tests. + */ + + context.suite = function(title, fn){ + var suite = Suite.create(suites[0], title); + suites.unshift(suite); + fn.call(suite); + suites.shift(); + return suite; + }; + + /** + * Pending suite. + */ + context.suite.skip = function(title, fn) { + var suite = Suite.create(suites[0], title); + suite.pending = true; + suites.unshift(suite); + fn.call(suite); + suites.shift(); + }; + + /** + * Exclusive test-case. + */ + + context.suite.only = function(title, fn){ + var suite = context.suite(title, fn); + mocha.grep(suite.fullTitle()); + }; + + /** + * Describe a specification or test-case + * with the given `title` and callback `fn` + * acting as a thunk. + */ + + context.test = function(title, fn){ + var suite = suites[0]; + if (suite.pending) var fn = null; + var test = new Test(title, fn); + suite.addTest(test); + return test; + }; + + /** + * Exclusive test-case. + */ + + context.test.only = function(title, fn){ + var test = context.test(title, fn); + var reString = '^' + utils.escapeRegexp(test.fullTitle()) + '$'; + mocha.grep(new RegExp(reString)); + }; + + /** + * Pending test case. + */ + + context.test.skip = function(title){ + context.test(title); + }; + }); +}; + +}); // module: interfaces/tdd.js + +require.register("mocha.js", function(module, exports, require){ +/*! + * mocha + * Copyright(c) 2011 TJ Holowaychuk + * MIT Licensed + */ + +/** + * Module dependencies. + */ + +var path = require('browser/path') + , utils = require('./utils'); + +/** + * Expose `Mocha`. + */ + +exports = module.exports = Mocha; + +/** + * Expose internals. + */ + +exports.utils = utils; +exports.interfaces = require('./interfaces'); +exports.reporters = require('./reporters'); +exports.Runnable = require('./runnable'); +exports.Context = require('./context'); +exports.Runner = require('./runner'); +exports.Suite = require('./suite'); +exports.Hook = require('./hook'); +exports.Test = require('./test'); + +/** + * Return image `name` path. + * + * @param {String} name + * @return {String} + * @api private + */ + +function image(name) { + return __dirname + '/../images/' + name + '.png'; +} + +/** + * Setup mocha with `options`. + * + * Options: + * + * - `ui` name "bdd", "tdd", "exports" etc + * - `reporter` reporter instance, defaults to `mocha.reporters.Dot` + * - `globals` array of accepted globals + * - `timeout` timeout in milliseconds + * - `bail` bail on the first test failure + * - `slow` milliseconds to wait before considering a test slow + * - `ignoreLeaks` ignore global leaks + * - `grep` string or regexp to filter tests with + * + * @param {Object} options + * @api public + */ + +function Mocha(options) { + options = options || {}; + this.files = []; + this.options = options; + this.grep(options.grep); + this.suite = new exports.Suite('', new exports.Context); + this.ui(options.ui); + this.bail(options.bail); + this.reporter(options.reporter); + if (null != options.timeout) this.timeout(options.timeout); + if (options.slow) this.slow(options.slow); +} + +/** + * Enable or disable bailing on the first failure. + * + * @param {Boolean} [bail] + * @api public + */ + +Mocha.prototype.bail = function(bail){ + if (0 == arguments.length) bail = true; + this.suite.bail(bail); + return this; +}; + +/** + * Add test `file`. + * + * @param {String} file + * @api public + */ + +Mocha.prototype.addFile = function(file){ + this.files.push(file); + return this; +}; + +/** + * Set reporter to `reporter`, defaults to "dot". + * + * @param {String|Function} reporter name or constructor + * @api public + */ + +Mocha.prototype.reporter = function(reporter){ + if ('function' == typeof reporter) { + this._reporter = reporter; + } else { + reporter = reporter || 'dot'; + try { + this._reporter = require('./reporters/' + reporter); + } catch (err) { + this._reporter = require(reporter); + } + if (!this._reporter) throw new Error('invalid reporter "' + reporter + '"'); + } + return this; +}; + +/** + * Set test UI `name`, defaults to "bdd". + * + * @param {String} bdd + * @api public + */ + +Mocha.prototype.ui = function(name){ + name = name || 'bdd'; + this._ui = exports.interfaces[name]; + if (!this._ui) throw new Error('invalid interface "' + name + '"'); + this._ui = this._ui(this.suite); + return this; +}; + +/** + * Load registered files. + * + * @api private + */ + +Mocha.prototype.loadFiles = function(fn){ + var self = this; + var suite = this.suite; + var pending = this.files.length; + this.files.forEach(function(file){ + file = path.resolve(file); + suite.emit('pre-require', global, file, self); + suite.emit('require', require(file), file, self); + suite.emit('post-require', global, file, self); + --pending || (fn && fn()); + }); +}; + +/** + * Enable growl support. + * + * @api private + */ + +Mocha.prototype._growl = function(runner, reporter) { + var notify = require('growl'); + + runner.on('end', function(){ + var stats = reporter.stats; + if (stats.failures) { + var msg = stats.failures + ' of ' + runner.total + ' tests failed'; + notify(msg, { name: 'mocha', title: 'Failed', image: image('error') }); + } else { + notify(stats.passes + ' tests passed in ' + stats.duration + 'ms', { + name: 'mocha' + , title: 'Passed' + , image: image('ok') + }); + } + }); +}; + +/** + * Add regexp to grep, if `re` is a string it is escaped. + * + * @param {RegExp|String} re + * @return {Mocha} + * @api public + */ + +Mocha.prototype.grep = function(re){ + this.options.grep = 'string' == typeof re + ? new RegExp(utils.escapeRegexp(re)) + : re; + return this; +}; + +/** + * Invert `.grep()` matches. + * + * @return {Mocha} + * @api public + */ + +Mocha.prototype.invert = function(){ + this.options.invert = true; + return this; +}; + +/** + * Ignore global leaks. + * + * @param {Boolean} ignore + * @return {Mocha} + * @api public + */ + +Mocha.prototype.ignoreLeaks = function(ignore){ + this.options.ignoreLeaks = !!ignore; + return this; +}; + +/** + * Enable global leak checking. + * + * @return {Mocha} + * @api public + */ + +Mocha.prototype.checkLeaks = function(){ + this.options.ignoreLeaks = false; + return this; +}; + +/** + * Enable growl support. + * + * @return {Mocha} + * @api public + */ + +Mocha.prototype.growl = function(){ + this.options.growl = true; + return this; +}; + +/** + * Ignore `globals` array or string. + * + * @param {Array|String} globals + * @return {Mocha} + * @api public + */ + +Mocha.prototype.globals = function(globals){ + this.options.globals = (this.options.globals || []).concat(globals); + return this; +}; + +/** + * Set the timeout in milliseconds. + * + * @param {Number} timeout + * @return {Mocha} + * @api public + */ + +Mocha.prototype.timeout = function(timeout){ + this.suite.timeout(timeout); + return this; +}; + +/** + * Set slowness threshold in milliseconds. + * + * @param {Number} slow + * @return {Mocha} + * @api public + */ + +Mocha.prototype.slow = function(slow){ + this.suite.slow(slow); + return this; +}; + +/** + * Makes all tests async (accepting a callback) + * + * @return {Mocha} + * @api public + */ + +Mocha.prototype.asyncOnly = function(){ + this.options.asyncOnly = true; + return this; +}; + +/** + * Run tests and invoke `fn()` when complete. + * + * @param {Function} fn + * @return {Runner} + * @api public + */ + +Mocha.prototype.run = function(fn){ + if (this.files.length) this.loadFiles(); + var suite = this.suite; + var options = this.options; + var runner = new exports.Runner(suite); + var reporter = new this._reporter(runner); + runner.ignoreLeaks = false !== options.ignoreLeaks; + runner.asyncOnly = options.asyncOnly; + if (options.grep) runner.grep(options.grep, options.invert); + if (options.globals) runner.globals(options.globals); + if (options.growl) this._growl(runner, reporter); + return runner.run(fn); +}; + +}); // module: mocha.js + +require.register("ms.js", function(module, exports, require){ +/** + * Helpers. + */ + +var s = 1000; +var m = s * 60; +var h = m * 60; +var d = h * 24; +var y = d * 365.25; + +/** + * Parse or format the given `val`. + * + * Options: + * + * - `long` verbose formatting [false] + * + * @param {String|Number} val + * @param {Object} options + * @return {String|Number} + * @api public + */ + +module.exports = function(val, options){ + options = options || {}; + if ('string' == typeof val) return parse(val); + return options.long + ? long(val) + : short(val); +}; + +/** + * Parse the given `str` and return milliseconds. + * + * @param {String} str + * @return {Number} + * @api private + */ + +function parse(str) { + var match = /^((?:\d+)?\.?\d+) *(ms|seconds?|s|minutes?|m|hours?|h|days?|d|years?|y)?$/i.exec(str); + if (!match) return; + var n = parseFloat(match[1]); + var type = (match[2] || 'ms').toLowerCase(); + switch (type) { + case 'years': + case 'year': + case 'y': + return n * y; + case 'days': + case 'day': + case 'd': + return n * d; + case 'hours': + case 'hour': + case 'h': + return n * h; + case 'minutes': + case 'minute': + case 'm': + return n * m; + case 'seconds': + case 'second': + case 's': + return n * s; + case 'ms': + return n; + } +} + +/** + * Short format for `ms`. + * + * @param {Number} ms + * @return {String} + * @api private + */ + +function short(ms) { + if (ms >= d) return Math.round(ms / d) + 'd'; + if (ms >= h) return Math.round(ms / h) + 'h'; + if (ms >= m) return Math.round(ms / m) + 'm'; + if (ms >= s) return Math.round(ms / s) + 's'; + return ms + 'ms'; +} + +/** + * Long format for `ms`. + * + * @param {Number} ms + * @return {String} + * @api private + */ + +function long(ms) { + return plural(ms, d, 'day') + || plural(ms, h, 'hour') + || plural(ms, m, 'minute') + || plural(ms, s, 'second') + || ms + ' ms'; +} + +/** + * Pluralization helper. + */ + +function plural(ms, n, name) { + if (ms < n) return; + if (ms < n * 1.5) return Math.floor(ms / n) + ' ' + name; + return Math.ceil(ms / n) + ' ' + name + 's'; +} + +}); // module: ms.js + +require.register("reporters/base.js", function(module, exports, require){ + +/** + * Module dependencies. + */ + +var tty = require('browser/tty') + , diff = require('browser/diff') + , ms = require('../ms'); + +/** + * Save timer references to avoid Sinon interfering (see GH-237). + */ + +var Date = global.Date + , setTimeout = global.setTimeout + , setInterval = global.setInterval + , clearTimeout = global.clearTimeout + , clearInterval = global.clearInterval; + +/** + * Check if both stdio streams are associated with a tty. + */ + +var isatty = tty.isatty(1) && tty.isatty(2); + +/** + * Expose `Base`. + */ + +exports = module.exports = Base; + +/** + * Enable coloring by default. + */ + +exports.useColors = isatty || (process.env.MOCHA_COLORS !== undefined); + +/** + * Inline diffs instead of +/- + */ + +exports.inlineDiffs = false; + +/** + * Default color map. + */ + +exports.colors = { + 'pass': 90 + , 'fail': 31 + , 'bright pass': 92 + , 'bright fail': 91 + , 'bright yellow': 93 + , 'pending': 36 + , 'suite': 0 + , 'error title': 0 + , 'error message': 31 + , 'error stack': 90 + , 'checkmark': 32 + , 'fast': 90 + , 'medium': 33 + , 'slow': 31 + , 'green': 32 + , 'light': 90 + , 'diff gutter': 90 + , 'diff added': 42 + , 'diff removed': 41 +}; + +/** + * Default symbol map. + */ + +exports.symbols = { + ok: '✓', + err: '✖', + dot: '․' +}; + +// With node.js on Windows: use symbols available in terminal default fonts +if ('win32' == process.platform) { + exports.symbols.ok = '\u221A'; + exports.symbols.err = '\u00D7'; + exports.symbols.dot = '.'; +} + +/** + * Color `str` with the given `type`, + * allowing colors to be disabled, + * as well as user-defined color + * schemes. + * + * @param {String} type + * @param {String} str + * @return {String} + * @api private + */ + +var color = exports.color = function(type, str) { + if (!exports.useColors) return str; + return '\u001b[' + exports.colors[type] + 'm' + str + '\u001b[0m'; +}; + +/** + * Expose term window size, with some + * defaults for when stderr is not a tty. + */ + +exports.window = { + width: isatty + ? process.stdout.getWindowSize + ? process.stdout.getWindowSize(1)[0] + : tty.getWindowSize()[1] + : 75 +}; + +/** + * Expose some basic cursor interactions + * that are common among reporters. + */ + +exports.cursor = { + hide: function(){ + process.stdout.write('\u001b[?25l'); + }, + + show: function(){ + process.stdout.write('\u001b[?25h'); + }, + + deleteLine: function(){ + process.stdout.write('\u001b[2K'); + }, + + beginningOfLine: function(){ + process.stdout.write('\u001b[0G'); + }, + + CR: function(){ + exports.cursor.deleteLine(); + exports.cursor.beginningOfLine(); + } +}; + +/** + * Outut the given `failures` as a list. + * + * @param {Array} failures + * @api public + */ + +exports.list = function(failures){ + console.error(); + failures.forEach(function(test, i){ + // format + var fmt = color('error title', ' %s) %s:\n') + + color('error message', ' %s') + + color('error stack', '\n%s\n'); + + // msg + var err = test.err + , message = err.message || '' + , stack = err.stack || message + , index = stack.indexOf(message) + message.length + , msg = stack.slice(0, index) + , actual = err.actual + , expected = err.expected + , escape = true; + + // uncaught + if (err.uncaught) { + msg = 'Uncaught ' + msg; + } + + // explicitly show diff + if (err.showDiff && sameType(actual, expected)) { + escape = false; + err.actual = actual = stringify(actual); + err.expected = expected = stringify(expected); + } + + // actual / expected diff + if ('string' == typeof actual && 'string' == typeof expected) { + fmt = color('error title', ' %s) %s:\n%s') + color('error stack', '\n%s\n'); + if (exports.inlineDiffs) { + msg = inlineDiff(err, escape); + } else { + msg = unifiedDiff(err, escape); + } + } + + // indent stack trace without msg + stack = stack.slice(index ? index + 1 : index) + .replace(/^/gm, ' '); + + console.error(fmt, (i + 1), test.fullTitle(), msg, stack); + }); +}; + +/** + * Initialize a new `Base` reporter. + * + * All other reporters generally + * inherit from this reporter, providing + * stats such as test duration, number + * of tests passed / failed etc. + * + * @param {Runner} runner + * @api public + */ + +function Base(runner) { + var self = this + , stats = this.stats = { suites: 0, tests: 0, passes: 0, pending: 0, failures: 0 } + , failures = this.failures = []; + + if (!runner) return; + this.runner = runner; + + runner.stats = stats; + + runner.on('start', function(){ + stats.start = new Date; + }); + + runner.on('suite', function(suite){ + stats.suites = stats.suites || 0; + suite.root || stats.suites++; + }); + + runner.on('test end', function(test){ + stats.tests = stats.tests || 0; + stats.tests++; + }); + + runner.on('pass', function(test){ + stats.passes = stats.passes || 0; + + var medium = test.slow() / 2; + test.speed = test.duration > test.slow() + ? 'slow' + : test.duration > medium + ? 'medium' + : 'fast'; + + stats.passes++; + }); + + runner.on('fail', function(test, err){ + stats.failures = stats.failures || 0; + stats.failures++; + test.err = err; + failures.push(test); + }); + + runner.on('end', function(){ + stats.end = new Date; + stats.duration = new Date - stats.start; + }); + + runner.on('pending', function(){ + stats.pending++; + }); +} + +/** + * Output common epilogue used by many of + * the bundled reporters. + * + * @api public + */ + +Base.prototype.epilogue = function(){ + var stats = this.stats; + var tests; + var fmt; + + console.log(); + + // passes + fmt = color('bright pass', ' ') + + color('green', ' %d passing') + + color('light', ' (%s)'); + + console.log(fmt, + stats.passes || 0, + ms(stats.duration)); + + // pending + if (stats.pending) { + fmt = color('pending', ' ') + + color('pending', ' %d pending'); + + console.log(fmt, stats.pending); + } + + // failures + if (stats.failures) { + fmt = color('fail', ' %d failing'); + + console.error(fmt, + stats.failures); + + Base.list(this.failures); + console.error(); + } + + console.log(); +}; + +/** + * Pad the given `str` to `len`. + * + * @param {String} str + * @param {String} len + * @return {String} + * @api private + */ + +function pad(str, len) { + str = String(str); + return Array(len - str.length + 1).join(' ') + str; +} + + +/** + * Returns an inline diff between 2 strings with coloured ANSI output + * + * @param {Error} Error with actual/expected + * @return {String} Diff + * @api private + */ + +function inlineDiff(err, escape) { + var msg = errorDiff(err, 'WordsWithSpace', escape); + + // linenos + var lines = msg.split('\n'); + if (lines.length > 4) { + var width = String(lines.length).length; + msg = lines.map(function(str, i){ + return pad(++i, width) + ' |' + ' ' + str; + }).join('\n'); + } + + // legend + msg = '\n' + + color('diff removed', 'actual') + + ' ' + + color('diff added', 'expected') + + '\n\n' + + msg + + '\n'; + + // indent + msg = msg.replace(/^/gm, ' '); + return msg; +} + +/** + * Returns a unified diff between 2 strings + * + * @param {Error} Error with actual/expected + * @return {String} Diff + * @api private + */ + +function unifiedDiff(err, escape) { + var indent = ' '; + function cleanUp(line) { + if (escape) { + line = escapeInvisibles(line); + } + if (line[0] === '+') return indent + colorLines('diff added', line); + if (line[0] === '-') return indent + colorLines('diff removed', line); + if (line.match(/\@\@/)) return null; + if (line.match(/\\ No newline/)) return null; + else return indent + line; + } + function notBlank(line) { + return line != null; + } + msg = diff.createPatch('string', err.actual, err.expected); + var lines = msg.split('\n').splice(4); + return '\n ' + + colorLines('diff added', '+ expected') + ' ' + + colorLines('diff removed', '- actual') + + '\n\n' + + lines.map(cleanUp).filter(notBlank).join('\n'); +} + +/** + * Return a character diff for `err`. + * + * @param {Error} err + * @return {String} + * @api private + */ + +function errorDiff(err, type, escape) { + var actual = escape ? escapeInvisibles(err.actual) : err.actual; + var expected = escape ? escapeInvisibles(err.expected) : err.expected; + return diff['diff' + type](actual, expected).map(function(str){ + if (str.added) return colorLines('diff added', str.value); + if (str.removed) return colorLines('diff removed', str.value); + return str.value; + }).join(''); +} + +/** + * Returns a string with all invisible characters in plain text + * + * @param {String} line + * @return {String} + * @api private + */ +function escapeInvisibles(line) { + return line.replace(/\t/g, '') + .replace(/\r/g, '') + .replace(/\n/g, '\n'); +} + +/** + * Color lines for `str`, using the color `name`. + * + * @param {String} name + * @param {String} str + * @return {String} + * @api private + */ + +function colorLines(name, str) { + return str.split('\n').map(function(str){ + return color(name, str); + }).join('\n'); +} + +/** + * Stringify `obj`. + * + * @param {Mixed} obj + * @return {String} + * @api private + */ + +function stringify(obj) { + if (obj instanceof RegExp) return obj.toString(); + return JSON.stringify(obj, null, 2); +} + +/** + * Check that a / b have the same type. + * + * @param {Object} a + * @param {Object} b + * @return {Boolean} + * @api private + */ + +function sameType(a, b) { + a = Object.prototype.toString.call(a); + b = Object.prototype.toString.call(b); + return a == b; +} + +}); // module: reporters/base.js + +require.register("reporters/doc.js", function(module, exports, require){ + +/** + * Module dependencies. + */ + +var Base = require('./base') + , utils = require('../utils'); + +/** + * Expose `Doc`. + */ + +exports = module.exports = Doc; + +/** + * Initialize a new `Doc` reporter. + * + * @param {Runner} runner + * @api public + */ + +function Doc(runner) { + Base.call(this, runner); + + var self = this + , stats = this.stats + , total = runner.total + , indents = 2; + + function indent() { + return Array(indents).join(' '); + } + + runner.on('suite', function(suite){ + if (suite.root) return; + ++indents; + console.log('%s
', indent()); + ++indents; + console.log('%s

%s

', indent(), utils.escape(suite.title)); + console.log('%s
', indent()); + }); + + runner.on('suite end', function(suite){ + if (suite.root) return; + console.log('%s
', indent()); + --indents; + console.log('%s
', indent()); + --indents; + }); + + runner.on('pass', function(test){ + console.log('%s
%s
', indent(), utils.escape(test.title)); + var code = utils.escape(utils.clean(test.fn.toString())); + console.log('%s 
%s
', indent(), code); + }); +} + +}); // module: reporters/doc.js + +require.register("reporters/dot.js", function(module, exports, require){ + +/** + * Module dependencies. + */ + +var Base = require('./base') + , color = Base.color; + +/** + * Expose `Dot`. + */ + +exports = module.exports = Dot; + +/** + * Initialize a new `Dot` matrix test reporter. + * + * @param {Runner} runner + * @api public + */ + +function Dot(runner) { + Base.call(this, runner); + + var self = this + , stats = this.stats + , width = Base.window.width * .75 | 0 + , n = 0; + + runner.on('start', function(){ + process.stdout.write('\n '); + }); + + runner.on('pending', function(test){ + process.stdout.write(color('pending', Base.symbols.dot)); + }); + + runner.on('pass', function(test){ + if (++n % width == 0) process.stdout.write('\n '); + if ('slow' == test.speed) { + process.stdout.write(color('bright yellow', Base.symbols.dot)); + } else { + process.stdout.write(color(test.speed, Base.symbols.dot)); + } + }); + + runner.on('fail', function(test, err){ + if (++n % width == 0) process.stdout.write('\n '); + process.stdout.write(color('fail', Base.symbols.dot)); + }); + + runner.on('end', function(){ + console.log(); + self.epilogue(); + }); +} + +/** + * Inherit from `Base.prototype`. + */ + +function F(){}; +F.prototype = Base.prototype; +Dot.prototype = new F; +Dot.prototype.constructor = Dot; + +}); // module: reporters/dot.js + +require.register("reporters/html-cov.js", function(module, exports, require){ + +/** + * Module dependencies. + */ + +var JSONCov = require('./json-cov') + , fs = require('browser/fs'); + +/** + * Expose `HTMLCov`. + */ + +exports = module.exports = HTMLCov; + +/** + * Initialize a new `JsCoverage` reporter. + * + * @param {Runner} runner + * @api public + */ + +function HTMLCov(runner) { + var jade = require('jade') + , file = __dirname + '/templates/coverage.jade' + , str = fs.readFileSync(file, 'utf8') + , fn = jade.compile(str, { filename: file }) + , self = this; + + JSONCov.call(this, runner, false); + + runner.on('end', function(){ + process.stdout.write(fn({ + cov: self.cov + , coverageClass: coverageClass + })); + }); +} + +/** + * Return coverage class for `n`. + * + * @return {String} + * @api private + */ + +function coverageClass(n) { + if (n >= 75) return 'high'; + if (n >= 50) return 'medium'; + if (n >= 25) return 'low'; + return 'terrible'; +} +}); // module: reporters/html-cov.js + +require.register("reporters/html.js", function(module, exports, require){ + +/** + * Module dependencies. + */ + +var Base = require('./base') + , utils = require('../utils') + , Progress = require('../browser/progress') + , escape = utils.escape; + +/** + * Save timer references to avoid Sinon interfering (see GH-237). + */ + +var Date = global.Date + , setTimeout = global.setTimeout + , setInterval = global.setInterval + , clearTimeout = global.clearTimeout + , clearInterval = global.clearInterval; + +/** + * Expose `Doc`. + */ + +exports = module.exports = HTML; + +/** + * Stats template. + */ + +var statsTemplate = ''; + +/** + * Initialize a new `Doc` reporter. + * + * @param {Runner} runner + * @api public + */ + +function HTML(runner, root) { + Base.call(this, runner); + + var self = this + , stats = this.stats + , total = runner.total + , stat = fragment(statsTemplate) + , items = stat.getElementsByTagName('li') + , passes = items[1].getElementsByTagName('em')[0] + , passesLink = items[1].getElementsByTagName('a')[0] + , failures = items[2].getElementsByTagName('em')[0] + , failuresLink = items[2].getElementsByTagName('a')[0] + , duration = items[3].getElementsByTagName('em')[0] + , canvas = stat.getElementsByTagName('canvas')[0] + , report = fragment('
    ') + , stack = [report] + , progress + , ctx + + root = root || document.getElementById('mocha'); + + if (canvas.getContext) { + var ratio = window.devicePixelRatio || 1; + canvas.style.width = canvas.width; + canvas.style.height = canvas.height; + canvas.width *= ratio; + canvas.height *= ratio; + ctx = canvas.getContext('2d'); + ctx.scale(ratio, ratio); + progress = new Progress; + } + + if (!root) return error('#mocha div missing, add it to your document'); + + // pass toggle + on(passesLink, 'click', function(){ + unhide(); + var name = /pass/.test(report.className) ? '' : ' pass'; + report.className = report.className.replace(/fail|pass/g, '') + name; + if (report.className.trim()) hideSuitesWithout('test pass'); + }); + + // failure toggle + on(failuresLink, 'click', function(){ + unhide(); + var name = /fail/.test(report.className) ? '' : ' fail'; + report.className = report.className.replace(/fail|pass/g, '') + name; + if (report.className.trim()) hideSuitesWithout('test fail'); + }); + + root.appendChild(stat); + root.appendChild(report); + + if (progress) progress.size(40); + + runner.on('suite', function(suite){ + if (suite.root) return; + + // suite + var url = '?grep=' + encodeURIComponent(suite.fullTitle()); + var el = fragment('

  • %s

    • ', url, escape(suite.title)); + + // container + stack[0].appendChild(el); + stack.unshift(document.createElement('ul')); + el.appendChild(stack[0]); + }); + + runner.on('suite end', function(suite){ + if (suite.root) return; + stack.shift(); + }); + + runner.on('fail', function(test, err){ + if ('hook' == test.type) runner.emit('test end', test); + }); + + runner.on('test end', function(test){ + // TODO: add to stats + var percent = stats.tests / this.total * 100 | 0; + if (progress) progress.update(percent).draw(ctx); + + // update stats + var ms = new Date - stats.start; + text(passes, stats.passes); + text(failures, stats.failures); + text(duration, (ms / 1000).toFixed(2)); + + // test + if ('passed' == test.state) { + var el = fragment('

  • %e%ems ‣

    • ', test.speed, test.title, test.duration, encodeURIComponent(test.fullTitle())); + } else if (test.pending) { + var el = fragment('

  • %e

    • ', test.title); + } else { + var el = fragment('

  • %e ‣

    • ', test.title, encodeURIComponent(test.fullTitle())); + var str = test.err.stack || test.err.toString(); + + // FF / Opera do not add the message + if (!~str.indexOf(test.err.message)) { + str = test.err.message + '\n' + str; + } + + // <=IE7 stringifies to [Object Error]. Since it can be overloaded, we + // check for the result of the stringifying. + if ('[object Error]' == str) str = test.err.message; + + // Safari doesn't give you a stack. Let's at least provide a source line. + if (!test.err.stack && test.err.sourceURL && test.err.line !== undefined) { + str += "\n(" + test.err.sourceURL + ":" + test.err.line + ")"; + } + + el.appendChild(fragment('
    %e
    ', str)); + } + + // toggle code + // TODO: defer + if (!test.pending) { + var h2 = el.getElementsByTagName('h2')[0]; + + on(h2, 'click', function(){ + pre.style.display = 'none' == pre.style.display + ? 'block' + : 'none'; + }); + + var pre = fragment('
    %e
    ', utils.clean(test.fn.toString())); + el.appendChild(pre); + pre.style.display = 'none'; + } + + // Don't call .appendChild if #mocha-report was already .shift()'ed off the stack. + if (stack[0]) stack[0].appendChild(el); + }); +} + +/** + * Display error `msg`. + */ + +function error(msg) { + document.body.appendChild(fragment('
    %s
    ', msg)); +} + +/** + * Return a DOM fragment from `html`. + */ + +function fragment(html) { + var args = arguments + , div = document.createElement('div') + , i = 1; + + div.innerHTML = html.replace(/%([se])/g, function(_, type){ + switch (type) { + case 's': return String(args[i++]); + case 'e': return escape(args[i++]); + } + }); + + return div.firstChild; +} + +/** + * Check for suites that do not have elements + * with `classname`, and hide them. + */ + +function hideSuitesWithout(classname) { + var suites = document.getElementsByClassName('suite'); + for (var i = 0; i < suites.length; i++) { + var els = suites[i].getElementsByClassName(classname); + if (0 == els.length) suites[i].className += ' hidden'; + } +} + +/** + * Unhide .hidden suites. + */ + +function unhide() { + var els = document.getElementsByClassName('suite hidden'); + for (var i = 0; i < els.length; ++i) { + els[i].className = els[i].className.replace('suite hidden', 'suite'); + } +} + +/** + * Set `el` text to `str`. + */ + +function text(el, str) { + if (el.textContent) { + el.textContent = str; + } else { + el.innerText = str; + } +} + +/** + * Listen on `event` with callback `fn`. + */ + +function on(el, event, fn) { + if (el.addEventListener) { + el.addEventListener(event, fn, false); + } else { + el.attachEvent('on' + event, fn); + } +} + +}); // module: reporters/html.js + +require.register("reporters/index.js", function(module, exports, require){ + +exports.Base = require('./base'); +exports.Dot = require('./dot'); +exports.Doc = require('./doc'); +exports.TAP = require('./tap'); +exports.JSON = require('./json'); +exports.HTML = require('./html'); +exports.List = require('./list'); +exports.Min = require('./min'); +exports.Spec = require('./spec'); +exports.Nyan = require('./nyan'); +exports.XUnit = require('./xunit'); +exports.Markdown = require('./markdown'); +exports.Progress = require('./progress'); +exports.Landing = require('./landing'); +exports.JSONCov = require('./json-cov'); +exports.HTMLCov = require('./html-cov'); +exports.JSONStream = require('./json-stream'); + +}); // module: reporters/index.js + +require.register("reporters/json-cov.js", function(module, exports, require){ + +/** + * Module dependencies. + */ + +var Base = require('./base'); + +/** + * Expose `JSONCov`. + */ + +exports = module.exports = JSONCov; + +/** + * Initialize a new `JsCoverage` reporter. + * + * @param {Runner} runner + * @param {Boolean} output + * @api public + */ + +function JSONCov(runner, output) { + var self = this + , output = 1 == arguments.length ? true : output; + + Base.call(this, runner); + + var tests = [] + , failures = [] + , passes = []; + + runner.on('test end', function(test){ + tests.push(test); + }); + + runner.on('pass', function(test){ + passes.push(test); + }); + + runner.on('fail', function(test){ + failures.push(test); + }); + + runner.on('end', function(){ + var cov = global._$jscoverage || {}; + var result = self.cov = map(cov); + result.stats = self.stats; + result.tests = tests.map(clean); + result.failures = failures.map(clean); + result.passes = passes.map(clean); + if (!output) return; + process.stdout.write(JSON.stringify(result, null, 2 )); + }); +} + +/** + * Map jscoverage data to a JSON structure + * suitable for reporting. + * + * @param {Object} cov + * @return {Object} + * @api private + */ + +function map(cov) { + var ret = { + instrumentation: 'node-jscoverage' + , sloc: 0 + , hits: 0 + , misses: 0 + , coverage: 0 + , files: [] + }; + + for (var filename in cov) { + var data = coverage(filename, cov[filename]); + ret.files.push(data); + ret.hits += data.hits; + ret.misses += data.misses; + ret.sloc += data.sloc; + } + + ret.files.sort(function(a, b) { + return a.filename.localeCompare(b.filename); + }); + + if (ret.sloc > 0) { + ret.coverage = (ret.hits / ret.sloc) * 100; + } + + return ret; +}; + +/** + * Map jscoverage data for a single source file + * to a JSON structure suitable for reporting. + * + * @param {String} filename name of the source file + * @param {Object} data jscoverage coverage data + * @return {Object} + * @api private + */ + +function coverage(filename, data) { + var ret = { + filename: filename, + coverage: 0, + hits: 0, + misses: 0, + sloc: 0, + source: {} + }; + + data.source.forEach(function(line, num){ + num++; + + if (data[num] === 0) { + ret.misses++; + ret.sloc++; + } else if (data[num] !== undefined) { + ret.hits++; + ret.sloc++; + } + + ret.source[num] = { + source: line + , coverage: data[num] === undefined + ? '' + : data[num] + }; + }); + + ret.coverage = ret.hits / ret.sloc * 100; + + return ret; +} + +/** + * Return a plain-object representation of `test` + * free of cyclic properties etc. + * + * @param {Object} test + * @return {Object} + * @api private + */ + +function clean(test) { + return { + title: test.title + , fullTitle: test.fullTitle() + , duration: test.duration + } +} + +}); // module: reporters/json-cov.js + +require.register("reporters/json-stream.js", function(module, exports, require){ + +/** + * Module dependencies. + */ + +var Base = require('./base') + , color = Base.color; + +/** + * Expose `List`. + */ + +exports = module.exports = List; + +/** + * Initialize a new `List` test reporter. + * + * @param {Runner} runner + * @api public + */ + +function List(runner) { + Base.call(this, runner); + + var self = this + , stats = this.stats + , total = runner.total; + + runner.on('start', function(){ + console.log(JSON.stringify(['start', { total: total }])); + }); + + runner.on('pass', function(test){ + console.log(JSON.stringify(['pass', clean(test)])); + }); + + runner.on('fail', function(test, err){ + console.log(JSON.stringify(['fail', clean(test)])); + }); + + runner.on('end', function(){ + process.stdout.write(JSON.stringify(['end', self.stats])); + }); +} + +/** + * Return a plain-object representation of `test` + * free of cyclic properties etc. + * + * @param {Object} test + * @return {Object} + * @api private + */ + +function clean(test) { + return { + title: test.title + , fullTitle: test.fullTitle() + , duration: test.duration + } +} +}); // module: reporters/json-stream.js + +require.register("reporters/json.js", function(module, exports, require){ + +/** + * Module dependencies. + */ + +var Base = require('./base') + , cursor = Base.cursor + , color = Base.color; + +/** + * Expose `JSON`. + */ + +exports = module.exports = JSONReporter; + +/** + * Initialize a new `JSON` reporter. + * + * @param {Runner} runner + * @api public + */ + +function JSONReporter(runner) { + var self = this; + Base.call(this, runner); + + var tests = [] + , failures = [] + , passes = []; + + runner.on('test end', function(test){ + tests.push(test); + }); + + runner.on('pass', function(test){ + passes.push(test); + }); + + runner.on('fail', function(test){ + failures.push(test); + }); + + runner.on('end', function(){ + var obj = { + stats: self.stats + , tests: tests.map(clean) + , failures: failures.map(clean) + , passes: passes.map(clean) + }; + + process.stdout.write(JSON.stringify(obj, null, 2)); + }); +} + +/** + * Return a plain-object representation of `test` + * free of cyclic properties etc. + * + * @param {Object} test + * @return {Object} + * @api private + */ + +function clean(test) { + return { + title: test.title + , fullTitle: test.fullTitle() + , duration: test.duration + } +} +}); // module: reporters/json.js + +require.register("reporters/landing.js", function(module, exports, require){ + +/** + * Module dependencies. + */ + +var Base = require('./base') + , cursor = Base.cursor + , color = Base.color; + +/** + * Expose `Landing`. + */ + +exports = module.exports = Landing; + +/** + * Airplane color. + */ + +Base.colors.plane = 0; + +/** + * Airplane crash color. + */ + +Base.colors['plane crash'] = 31; + +/** + * Runway color. + */ + +Base.colors.runway = 90; + +/** + * Initialize a new `Landing` reporter. + * + * @param {Runner} runner + * @api public + */ + +function Landing(runner) { + Base.call(this, runner); + + var self = this + , stats = this.stats + , width = Base.window.width * .75 | 0 + , total = runner.total + , stream = process.stdout + , plane = color('plane', '✈') + , crashed = -1 + , n = 0; + + function runway() { + var buf = Array(width).join('-'); + return ' ' + color('runway', buf); + } + + runner.on('start', function(){ + stream.write('\n '); + cursor.hide(); + }); + + runner.on('test end', function(test){ + // check if the plane crashed + var col = -1 == crashed + ? width * ++n / total | 0 + : crashed; + + // show the crash + if ('failed' == test.state) { + plane = color('plane crash', '✈'); + crashed = col; + } + + // render landing strip + stream.write('\u001b[4F\n\n'); + stream.write(runway()); + stream.write('\n '); + stream.write(color('runway', Array(col).join('⋅'))); + stream.write(plane) + stream.write(color('runway', Array(width - col).join('⋅') + '\n')); + stream.write(runway()); + stream.write('\u001b[0m'); + }); + + runner.on('end', function(){ + cursor.show(); + console.log(); + self.epilogue(); + }); +} + +/** + * Inherit from `Base.prototype`. + */ + +function F(){}; +F.prototype = Base.prototype; +Landing.prototype = new F; +Landing.prototype.constructor = Landing; + +}); // module: reporters/landing.js + +require.register("reporters/list.js", function(module, exports, require){ + +/** + * Module dependencies. + */ + +var Base = require('./base') + , cursor = Base.cursor + , color = Base.color; + +/** + * Expose `List`. + */ + +exports = module.exports = List; + +/** + * Initialize a new `List` test reporter. + * + * @param {Runner} runner + * @api public + */ + +function List(runner) { + Base.call(this, runner); + + var self = this + , stats = this.stats + , n = 0; + + runner.on('start', function(){ + console.log(); + }); + + runner.on('test', function(test){ + process.stdout.write(color('pass', ' ' + test.fullTitle() + ': ')); + }); + + runner.on('pending', function(test){ + var fmt = color('checkmark', ' -') + + color('pending', ' %s'); + console.log(fmt, test.fullTitle()); + }); + + runner.on('pass', function(test){ + var fmt = color('checkmark', ' '+Base.symbols.dot) + + color('pass', ' %s: ') + + color(test.speed, '%dms'); + cursor.CR(); + console.log(fmt, test.fullTitle(), test.duration); + }); + + runner.on('fail', function(test, err){ + cursor.CR(); + console.log(color('fail', ' %d) %s'), ++n, test.fullTitle()); + }); + + runner.on('end', self.epilogue.bind(self)); +} + +/** + * Inherit from `Base.prototype`. + */ + +function F(){}; +F.prototype = Base.prototype; +List.prototype = new F; +List.prototype.constructor = List; + + +}); // module: reporters/list.js + +require.register("reporters/markdown.js", function(module, exports, require){ +/** + * Module dependencies. + */ + +var Base = require('./base') + , utils = require('../utils'); + +/** + * Expose `Markdown`. + */ + +exports = module.exports = Markdown; + +/** + * Initialize a new `Markdown` reporter. + * + * @param {Runner} runner + * @api public + */ + +function Markdown(runner) { + Base.call(this, runner); + + var self = this + , stats = this.stats + , level = 0 + , buf = ''; + + function title(str) { + return Array(level).join('#') + ' ' + str; + } + + function indent() { + return Array(level).join(' '); + } + + function mapTOC(suite, obj) { + var ret = obj; + obj = obj[suite.title] = obj[suite.title] || { suite: suite }; + suite.suites.forEach(function(suite){ + mapTOC(suite, obj); + }); + return ret; + } + + function stringifyTOC(obj, level) { + ++level; + var buf = ''; + var link; + for (var key in obj) { + if ('suite' == key) continue; + if (key) link = ' - [' + key + '](#' + utils.slug(obj[key].suite.fullTitle()) + ')\n'; + if (key) buf += Array(level).join(' ') + link; + buf += stringifyTOC(obj[key], level); + } + --level; + return buf; + } + + function generateTOC(suite) { + var obj = mapTOC(suite, {}); + return stringifyTOC(obj, 0); + } + + generateTOC(runner.suite); + + runner.on('suite', function(suite){ + ++level; + var slug = utils.slug(suite.fullTitle()); + buf += '' + '\n'; + buf += title(suite.title) + '\n'; + }); + + runner.on('suite end', function(suite){ + --level; + }); + + runner.on('pass', function(test){ + var code = utils.clean(test.fn.toString()); + buf += test.title + '.\n'; + buf += '\n```js\n'; + buf += code + '\n'; + buf += '```\n\n'; + }); + + runner.on('end', function(){ + process.stdout.write('# TOC\n'); + process.stdout.write(generateTOC(runner.suite)); + process.stdout.write(buf); + }); +} +}); // module: reporters/markdown.js + +require.register("reporters/min.js", function(module, exports, require){ + +/** + * Module dependencies. + */ + +var Base = require('./base'); + +/** + * Expose `Min`. + */ + +exports = module.exports = Min; + +/** + * Initialize a new `Min` minimal test reporter (best used with --watch). + * + * @param {Runner} runner + * @api public + */ + +function Min(runner) { + Base.call(this, runner); + + runner.on('start', function(){ + // clear screen + process.stdout.write('\u001b[2J'); + // set cursor position + process.stdout.write('\u001b[1;3H'); + }); + + runner.on('end', this.epilogue.bind(this)); +} + +/** + * Inherit from `Base.prototype`. + */ + +function F(){}; +F.prototype = Base.prototype; +Min.prototype = new F; +Min.prototype.constructor = Min; + + +}); // module: reporters/min.js + +require.register("reporters/nyan.js", function(module, exports, require){ +/** + * Module dependencies. + */ + +var Base = require('./base') + , color = Base.color; + +/** + * Expose `Dot`. + */ + +exports = module.exports = NyanCat; + +/** + * Initialize a new `Dot` matrix test reporter. + * + * @param {Runner} runner + * @api public + */ + +function NyanCat(runner) { + Base.call(this, runner); + var self = this + , stats = this.stats + , width = Base.window.width * .75 | 0 + , rainbowColors = this.rainbowColors = self.generateColors() + , colorIndex = this.colorIndex = 0 + , numerOfLines = this.numberOfLines = 4 + , trajectories = this.trajectories = [[], [], [], []] + , nyanCatWidth = this.nyanCatWidth = 11 + , trajectoryWidthMax = this.trajectoryWidthMax = (width - nyanCatWidth) + , scoreboardWidth = this.scoreboardWidth = 5 + , tick = this.tick = 0 + , n = 0; + + runner.on('start', function(){ + Base.cursor.hide(); + self.draw(); + }); + + runner.on('pending', function(test){ + self.draw(); + }); + + runner.on('pass', function(test){ + self.draw(); + }); + + runner.on('fail', function(test, err){ + self.draw(); + }); + + runner.on('end', function(){ + Base.cursor.show(); + for (var i = 0; i < self.numberOfLines; i++) write('\n'); + self.epilogue(); + }); +} + +/** + * Draw the nyan cat + * + * @api private + */ + +NyanCat.prototype.draw = function(){ + this.appendRainbow(); + this.drawScoreboard(); + this.drawRainbow(); + this.drawNyanCat(); + this.tick = !this.tick; +}; + +/** + * Draw the "scoreboard" showing the number + * of passes, failures and pending tests. + * + * @api private + */ + +NyanCat.prototype.drawScoreboard = function(){ + var stats = this.stats; + var colors = Base.colors; + + function draw(color, n) { + write(' '); + write('\u001b[' + color + 'm' + n + '\u001b[0m'); + write('\n'); + } + + draw(colors.green, stats.passes); + draw(colors.fail, stats.failures); + draw(colors.pending, stats.pending); + write('\n'); + + this.cursorUp(this.numberOfLines); +}; + +/** + * Append the rainbow. + * + * @api private + */ + +NyanCat.prototype.appendRainbow = function(){ + var segment = this.tick ? '_' : '-'; + var rainbowified = this.rainbowify(segment); + + for (var index = 0; index < this.numberOfLines; index++) { + var trajectory = this.trajectories[index]; + if (trajectory.length >= this.trajectoryWidthMax) trajectory.shift(); + trajectory.push(rainbowified); + } +}; + +/** + * Draw the rainbow. + * + * @api private + */ + +NyanCat.prototype.drawRainbow = function(){ + var self = this; + + this.trajectories.forEach(function(line, index) { + write('\u001b[' + self.scoreboardWidth + 'C'); + write(line.join('')); + write('\n'); + }); + + this.cursorUp(this.numberOfLines); +}; + +/** + * Draw the nyan cat + * + * @api private + */ + +NyanCat.prototype.drawNyanCat = function() { + var self = this; + var startWidth = this.scoreboardWidth + this.trajectories[0].length; + var color = '\u001b[' + startWidth + 'C'; + var padding = ''; + + write(color); + write('_,------,'); + write('\n'); + + write(color); + padding = self.tick ? ' ' : ' '; + write('_|' + padding + '/\\_/\\ '); + write('\n'); + + write(color); + padding = self.tick ? '_' : '__'; + var tail = self.tick ? '~' : '^'; + var face; + write(tail + '|' + padding + this.face() + ' '); + write('\n'); + + write(color); + padding = self.tick ? ' ' : ' '; + write(padding + '"" "" '); + write('\n'); + + this.cursorUp(this.numberOfLines); +}; + +/** + * Draw nyan cat face. + * + * @return {String} + * @api private + */ + +NyanCat.prototype.face = function() { + var stats = this.stats; + if (stats.failures) { + return '( x .x)'; + } else if (stats.pending) { + return '( o .o)'; + } else if(stats.passes) { + return '( ^ .^)'; + } else { + return '( - .-)'; + } +} + +/** + * Move cursor up `n`. + * + * @param {Number} n + * @api private + */ + +NyanCat.prototype.cursorUp = function(n) { + write('\u001b[' + n + 'A'); +}; + +/** + * Move cursor down `n`. + * + * @param {Number} n + * @api private + */ + +NyanCat.prototype.cursorDown = function(n) { + write('\u001b[' + n + 'B'); +}; + +/** + * Generate rainbow colors. + * + * @return {Array} + * @api private + */ + +NyanCat.prototype.generateColors = function(){ + var colors = []; + + for (var i = 0; i < (6 * 7); i++) { + var pi3 = Math.floor(Math.PI / 3); + var n = (i * (1.0 / 6)); + var r = Math.floor(3 * Math.sin(n) + 3); + var g = Math.floor(3 * Math.sin(n + 2 * pi3) + 3); + var b = Math.floor(3 * Math.sin(n + 4 * pi3) + 3); + colors.push(36 * r + 6 * g + b + 16); + } + + return colors; +}; + +/** + * Apply rainbow to the given `str`. + * + * @param {String} str + * @return {String} + * @api private + */ + +NyanCat.prototype.rainbowify = function(str){ + var color = this.rainbowColors[this.colorIndex % this.rainbowColors.length]; + this.colorIndex += 1; + return '\u001b[38;5;' + color + 'm' + str + '\u001b[0m'; +}; + +/** + * Stdout helper. + */ + +function write(string) { + process.stdout.write(string); +} + +/** + * Inherit from `Base.prototype`. + */ + +function F(){}; +F.prototype = Base.prototype; +NyanCat.prototype = new F; +NyanCat.prototype.constructor = NyanCat; + + +}); // module: reporters/nyan.js + +require.register("reporters/progress.js", function(module, exports, require){ + +/** + * Module dependencies. + */ + +var Base = require('./base') + , cursor = Base.cursor + , color = Base.color; + +/** + * Expose `Progress`. + */ + +exports = module.exports = Progress; + +/** + * General progress bar color. + */ + +Base.colors.progress = 90; + +/** + * Initialize a new `Progress` bar test reporter. + * + * @param {Runner} runner + * @param {Object} options + * @api public + */ + +function Progress(runner, options) { + Base.call(this, runner); + + var self = this + , options = options || {} + , stats = this.stats + , width = Base.window.width * .50 | 0 + , total = runner.total + , complete = 0 + , max = Math.max; + + // default chars + options.open = options.open || '['; + options.complete = options.complete || '▬'; + options.incomplete = options.incomplete || Base.symbols.dot; + options.close = options.close || ']'; + options.verbose = false; + + // tests started + runner.on('start', function(){ + console.log(); + cursor.hide(); + }); + + // tests complete + runner.on('test end', function(){ + complete++; + var incomplete = total - complete + , percent = complete / total + , n = width * percent | 0 + , i = width - n; + + cursor.CR(); + process.stdout.write('\u001b[J'); + process.stdout.write(color('progress', ' ' + options.open)); + process.stdout.write(Array(n).join(options.complete)); + process.stdout.write(Array(i).join(options.incomplete)); + process.stdout.write(color('progress', options.close)); + if (options.verbose) { + process.stdout.write(color('progress', ' ' + complete + ' of ' + total)); + } + }); + + // tests are complete, output some stats + // and the failures if any + runner.on('end', function(){ + cursor.show(); + console.log(); + self.epilogue(); + }); +} + +/** + * Inherit from `Base.prototype`. + */ + +function F(){}; +F.prototype = Base.prototype; +Progress.prototype = new F; +Progress.prototype.constructor = Progress; + + +}); // module: reporters/progress.js + +require.register("reporters/spec.js", function(module, exports, require){ + +/** + * Module dependencies. + */ + +var Base = require('./base') + , cursor = Base.cursor + , color = Base.color; + +/** + * Expose `Spec`. + */ + +exports = module.exports = Spec; + +/** + * Initialize a new `Spec` test reporter. + * + * @param {Runner} runner + * @api public + */ + +function Spec(runner) { + Base.call(this, runner); + + var self = this + , stats = this.stats + , indents = 0 + , n = 0; + + function indent() { + return Array(indents).join(' ') + } + + runner.on('start', function(){ + console.log(); + }); + + runner.on('suite', function(suite){ + ++indents; + console.log(color('suite', '%s%s'), indent(), suite.title); + }); + + runner.on('suite end', function(suite){ + --indents; + if (1 == indents) console.log(); + }); + + runner.on('test', function(test){ + process.stdout.write(indent() + color('pass', ' ◦ ' + test.title + ': ')); + }); + + runner.on('pending', function(test){ + var fmt = indent() + color('pending', ' - %s'); + console.log(fmt, test.title); + }); + + runner.on('pass', function(test){ + if ('fast' == test.speed) { + var fmt = indent() + + color('checkmark', ' ' + Base.symbols.ok) + + color('pass', ' %s '); + cursor.CR(); + console.log(fmt, test.title); + } else { + var fmt = indent() + + color('checkmark', ' ' + Base.symbols.ok) + + color('pass', ' %s ') + + color(test.speed, '(%dms)'); + cursor.CR(); + console.log(fmt, test.title, test.duration); + } + }); + + runner.on('fail', function(test, err){ + cursor.CR(); + console.log(indent() + color('fail', ' %d) %s'), ++n, test.title); + }); + + runner.on('end', self.epilogue.bind(self)); +} + +/** + * Inherit from `Base.prototype`. + */ + +function F(){}; +F.prototype = Base.prototype; +Spec.prototype = new F; +Spec.prototype.constructor = Spec; + + +}); // module: reporters/spec.js + +require.register("reporters/tap.js", function(module, exports, require){ + +/** + * Module dependencies. + */ + +var Base = require('./base') + , cursor = Base.cursor + , color = Base.color; + +/** + * Expose `TAP`. + */ + +exports = module.exports = TAP; + +/** + * Initialize a new `TAP` reporter. + * + * @param {Runner} runner + * @api public + */ + +function TAP(runner) { + Base.call(this, runner); + + var self = this + , stats = this.stats + , n = 1 + , passes = 0 + , failures = 0; + + runner.on('start', function(){ + var total = runner.grepTotal(runner.suite); + console.log('%d..%d', 1, total); + }); + + runner.on('test end', function(){ + ++n; + }); + + runner.on('pending', function(test){ + console.log('ok %d %s # SKIP -', n, title(test)); + }); + + runner.on('pass', function(test){ + passes++; + console.log('ok %d %s', n, title(test)); + }); + + runner.on('fail', function(test, err){ + failures++; + console.log('not ok %d %s', n, title(test)); + if (err.stack) console.log(err.stack.replace(/^/gm, ' ')); + }); + + runner.on('end', function(){ + console.log('# tests ' + (passes + failures)); + console.log('# pass ' + passes); + console.log('# fail ' + failures); + }); +} + +/** + * Return a TAP-safe title of `test` + * + * @param {Object} test + * @return {String} + * @api private + */ + +function title(test) { + return test.fullTitle().replace(/#/g, ''); +} + +}); // module: reporters/tap.js + +require.register("reporters/xunit.js", function(module, exports, require){ + +/** + * Module dependencies. + */ + +var Base = require('./base') + , utils = require('../utils') + , escape = utils.escape; + +/** + * Save timer references to avoid Sinon interfering (see GH-237). + */ + +var Date = global.Date + , setTimeout = global.setTimeout + , setInterval = global.setInterval + , clearTimeout = global.clearTimeout + , clearInterval = global.clearInterval; + +/** + * Expose `XUnit`. + */ + +exports = module.exports = XUnit; + +/** + * Initialize a new `XUnit` reporter. + * + * @param {Runner} runner + * @api public + */ + +function XUnit(runner) { + Base.call(this, runner); + var stats = this.stats + , tests = [] + , self = this; + + runner.on('pass', function(test){ + tests.push(test); + }); + + runner.on('fail', function(test){ + tests.push(test); + }); + + runner.on('end', function(){ + console.log(tag('testsuite', { + name: 'Mocha Tests' + , tests: stats.tests + , failures: stats.failures + , errors: stats.failures + , skipped: stats.tests - stats.failures - stats.passes + , timestamp: (new Date).toUTCString() + , time: (stats.duration / 1000) || 0 + }, false)); + + tests.forEach(test); + console.log(''); + }); +} + +/** + * Inherit from `Base.prototype`. + */ + +function F(){}; +F.prototype = Base.prototype; +XUnit.prototype = new F; +XUnit.prototype.constructor = XUnit; + + +/** + * Output tag for the given `test.` + */ + +function test(test) { + var attrs = { + classname: test.parent.fullTitle() + , name: test.title + , time: test.duration / 1000 + }; + + if ('failed' == test.state) { + var err = test.err; + attrs.message = escape(err.message); + console.log(tag('testcase', attrs, false, tag('failure', attrs, false, cdata(err.stack)))); + } else if (test.pending) { + console.log(tag('testcase', attrs, false, tag('skipped', {}, true))); + } else { + console.log(tag('testcase', attrs, true) ); + } +} + +/** + * HTML tag helper. + */ + +function tag(name, attrs, close, content) { + var end = close ? '/>' : '>' + , pairs = [] + , tag; + + for (var key in attrs) { + pairs.push(key + '="' + escape(attrs[key]) + '"'); + } + + tag = '<' + name + (pairs.length ? ' ' + pairs.join(' ') : '') + end; + if (content) tag += content + ''; +} + +}); // module: reporters/xunit.js + +require.register("runnable.js", function(module, exports, require){ + +/** + * Module dependencies. + */ + +var EventEmitter = require('browser/events').EventEmitter + , debug = require('browser/debug')('mocha:runnable') + , milliseconds = require('./ms'); + +/** + * Save timer references to avoid Sinon interfering (see GH-237). + */ + +var Date = global.Date + , setTimeout = global.setTimeout + , setInterval = global.setInterval + , clearTimeout = global.clearTimeout + , clearInterval = global.clearInterval; + +/** + * Object#toString(). + */ + +var toString = Object.prototype.toString; + +/** + * Expose `Runnable`. + */ + +module.exports = Runnable; + +/** + * Initialize a new `Runnable` with the given `title` and callback `fn`. + * + * @param {String} title + * @param {Function} fn + * @api private + */ + +function Runnable(title, fn) { + this.title = title; + this.fn = fn; + this.async = fn && fn.length; + this.sync = ! this.async; + this._timeout = 2000; + this._slow = 75; + this.timedOut = false; +} + +/** + * Inherit from `EventEmitter.prototype`. + */ + +function F(){}; +F.prototype = EventEmitter.prototype; +Runnable.prototype = new F; +Runnable.prototype.constructor = Runnable; + + +/** + * Set & get timeout `ms`. + * + * @param {Number|String} ms + * @return {Runnable|Number} ms or self + * @api private + */ + +Runnable.prototype.timeout = function(ms){ + if (0 == arguments.length) return this._timeout; + if ('string' == typeof ms) ms = milliseconds(ms); + debug('timeout %d', ms); + this._timeout = ms; + if (this.timer) this.resetTimeout(); + return this; +}; + +/** + * Set & get slow `ms`. + * + * @param {Number|String} ms + * @return {Runnable|Number} ms or self + * @api private + */ + +Runnable.prototype.slow = function(ms){ + if (0 === arguments.length) return this._slow; + if ('string' == typeof ms) ms = milliseconds(ms); + debug('timeout %d', ms); + this._slow = ms; + return this; +}; + +/** + * Return the full title generated by recursively + * concatenating the parent's full title. + * + * @return {String} + * @api public + */ + +Runnable.prototype.fullTitle = function(){ + return this.parent.fullTitle() + ' ' + this.title; +}; + +/** + * Clear the timeout. + * + * @api private + */ + +Runnable.prototype.clearTimeout = function(){ + clearTimeout(this.timer); +}; + +/** + * Inspect the runnable void of private properties. + * + * @return {String} + * @api private + */ + +Runnable.prototype.inspect = function(){ + return JSON.stringify(this, function(key, val){ + if ('_' == key[0]) return; + if ('parent' == key) return '#'; + if ('ctx' == key) return '#'; + return val; + }, 2); +}; + +/** + * Reset the timeout. + * + * @api private + */ + +Runnable.prototype.resetTimeout = function(){ + var self = this; + var ms = this.timeout() || 1e9; + + this.clearTimeout(); + this.timer = setTimeout(function(){ + self.callback(new Error('timeout of ' + ms + 'ms exceeded')); + self.timedOut = true; + }, ms); +}; + +/** + * Run the test and invoke `fn(err)`. + * + * @param {Function} fn + * @api private + */ + +Runnable.prototype.run = function(fn){ + var self = this + , ms = this.timeout() + , start = new Date + , ctx = this.ctx + , finished + , emitted; + + if (ctx) ctx.runnable(this); + + // timeout + if (this.async) { + if (ms) { + this.timer = setTimeout(function(){ + done(new Error('timeout of ' + ms + 'ms exceeded')); + self.timedOut = true; + }, ms); + } + } + + // called multiple times + function multiple(err) { + if (emitted) return; + emitted = true; + self.emit('error', err || new Error('done() called multiple times')); + } + + // finished + function done(err) { + if (self.timedOut) return; + if (finished) return multiple(err); + self.clearTimeout(); + self.duration = new Date - start; + finished = true; + fn(err); + } + + // for .resetTimeout() + this.callback = done; + + // async + if (this.async) { + try { + this.fn.call(ctx, function(err){ + if (err instanceof Error || toString.call(err) === "[object Error]") return done(err); + if (null != err) return done(new Error('done() invoked with non-Error: ' + err)); + done(); + }); + } catch (err) { + done(err); + } + return; + } + + if (this.asyncOnly) { + return done(new Error('--async-only option in use without declaring `done()`')); + } + + // sync + try { + if (!this.pending) this.fn.call(ctx); + this.duration = new Date - start; + fn(); + } catch (err) { + fn(err); + } +}; + +}); // module: runnable.js + +require.register("runner.js", function(module, exports, require){ +/** + * Module dependencies. + */ + +var EventEmitter = require('browser/events').EventEmitter + , debug = require('browser/debug')('mocha:runner') + , Test = require('./test') + , utils = require('./utils') + , filter = utils.filter + , keys = utils.keys; + +/** + * Non-enumerable globals. + */ + +var globals = [ + 'setTimeout', + 'clearTimeout', + 'setInterval', + 'clearInterval', + 'XMLHttpRequest', + 'Date' +]; + +/** + * Expose `Runner`. + */ + +module.exports = Runner; + +/** + * Initialize a `Runner` for the given `suite`. + * + * Events: + * + * - `start` execution started + * - `end` execution complete + * - `suite` (suite) test suite execution started + * - `suite end` (suite) all tests (and sub-suites) have finished + * - `test` (test) test execution started + * - `test end` (test) test completed + * - `hook` (hook) hook execution started + * - `hook end` (hook) hook complete + * - `pass` (test) test passed + * - `fail` (test, err) test failed + * - `pending` (test) test pending + * + * @api public + */ + +function Runner(suite) { + var self = this; + this._globals = []; + this.suite = suite; + this.total = suite.total(); + this.failures = 0; + this.on('test end', function(test){ self.checkGlobals(test); }); + this.on('hook end', function(hook){ self.checkGlobals(hook); }); + this.grep(/.*/); + this.globals(this.globalProps().concat(['errno'])); +} + +/** + * Wrapper for setImmediate, process.nextTick, or browser polyfill. + * + * @param {Function} fn + * @api private + */ + +Runner.immediately = global.setImmediate || process.nextTick; + +/** + * Inherit from `EventEmitter.prototype`. + */ + +function F(){}; +F.prototype = EventEmitter.prototype; +Runner.prototype = new F; +Runner.prototype.constructor = Runner; + + +/** + * Run tests with full titles matching `re`. Updates runner.total + * with number of tests matched. + * + * @param {RegExp} re + * @param {Boolean} invert + * @return {Runner} for chaining + * @api public + */ + +Runner.prototype.grep = function(re, invert){ + debug('grep %s', re); + this._grep = re; + this._invert = invert; + this.total = this.grepTotal(this.suite); + return this; +}; + +/** + * Returns the number of tests matching the grep search for the + * given suite. + * + * @param {Suite} suite + * @return {Number} + * @api public + */ + +Runner.prototype.grepTotal = function(suite) { + var self = this; + var total = 0; + + suite.eachTest(function(test){ + var match = self._grep.test(test.fullTitle()); + if (self._invert) match = !match; + if (match) total++; + }); + + return total; +}; + +/** + * Return a list of global properties. + * + * @return {Array} + * @api private + */ + +Runner.prototype.globalProps = function() { + var props = utils.keys(global); + + // non-enumerables + for (var i = 0; i < globals.length; ++i) { + if (~utils.indexOf(props, globals[i])) continue; + props.push(globals[i]); + } + + return props; +}; + +/** + * Allow the given `arr` of globals. + * + * @param {Array} arr + * @return {Runner} for chaining + * @api public + */ + +Runner.prototype.globals = function(arr){ + if (0 == arguments.length) return this._globals; + debug('globals %j', arr); + utils.forEach(arr, function(arr){ + this._globals.push(arr); + }, this); + return this; +}; + +/** + * Check for global variable leaks. + * + * @api private + */ + +Runner.prototype.checkGlobals = function(test){ + if (this.ignoreLeaks) return; + var ok = this._globals; + var globals = this.globalProps(); + var isNode = process.kill; + var leaks; + + // check length - 2 ('errno' and 'location' globals) + if (isNode && 1 == ok.length - globals.length) return; + else if (2 == ok.length - globals.length) return; + + if(this.prevGlobalsLength == globals.length) return; + this.prevGlobalsLength = globals.length; + + leaks = filterLeaks(ok, globals); + this._globals = this._globals.concat(leaks); + + if (leaks.length > 1) { + this.fail(test, new Error('global leaks detected: ' + leaks.join(', ') + '')); + } else if (leaks.length) { + this.fail(test, new Error('global leak detected: ' + leaks[0])); + } +}; + +/** + * Fail the given `test`. + * + * @param {Test} test + * @param {Error} err + * @api private + */ + +Runner.prototype.fail = function(test, err){ + ++this.failures; + test.state = 'failed'; + + if ('string' == typeof err) { + err = new Error('the string "' + err + '" was thrown, throw an Error :)'); + } + + this.emit('fail', test, err); +}; + +/** + * Fail the given `hook` with `err`. + * + * Hook failures (currently) hard-end due + * to that fact that a failing hook will + * surely cause subsequent tests to fail, + * causing jumbled reporting. + * + * @param {Hook} hook + * @param {Error} err + * @api private + */ + +Runner.prototype.failHook = function(hook, err){ + this.fail(hook, err); + this.emit('end'); +}; + +/** + * Run hook `name` callbacks and then invoke `fn()`. + * + * @param {String} name + * @param {Function} function + * @api private + */ + +Runner.prototype.hook = function(name, fn){ + var suite = this.suite + , hooks = suite['_' + name] + , self = this + , timer; + + function next(i) { + var hook = hooks[i]; + if (!hook) return fn(); + if (self.failures && suite.bail()) return fn(); + self.currentRunnable = hook; + + hook.ctx.currentTest = self.test; + + self.emit('hook', hook); + + hook.on('error', function(err){ + self.failHook(hook, err); + }); + + hook.run(function(err){ + hook.removeAllListeners('error'); + var testError = hook.error(); + if (testError) self.fail(self.test, testError); + if (err) return self.failHook(hook, err); + self.emit('hook end', hook); + delete hook.ctx.currentTest; + next(++i); + }); + } + + Runner.immediately(function(){ + next(0); + }); +}; + +/** + * Run hook `name` for the given array of `suites` + * in order, and callback `fn(err)`. + * + * @param {String} name + * @param {Array} suites + * @param {Function} fn + * @api private + */ + +Runner.prototype.hooks = function(name, suites, fn){ + var self = this + , orig = this.suite; + + function next(suite) { + self.suite = suite; + + if (!suite) { + self.suite = orig; + return fn(); + } + + self.hook(name, function(err){ + if (err) { + self.suite = orig; + return fn(err); + } + + next(suites.pop()); + }); + } + + next(suites.pop()); +}; + +/** + * Run hooks from the top level down. + * + * @param {String} name + * @param {Function} fn + * @api private + */ + +Runner.prototype.hookUp = function(name, fn){ + var suites = [this.suite].concat(this.parents()).reverse(); + this.hooks(name, suites, fn); +}; + +/** + * Run hooks from the bottom up. + * + * @param {String} name + * @param {Function} fn + * @api private + */ + +Runner.prototype.hookDown = function(name, fn){ + var suites = [this.suite].concat(this.parents()); + this.hooks(name, suites, fn); +}; + +/** + * Return an array of parent Suites from + * closest to furthest. + * + * @return {Array} + * @api private + */ + +Runner.prototype.parents = function(){ + var suite = this.suite + , suites = []; + while (suite = suite.parent) suites.push(suite); + return suites; +}; + +/** + * Run the current test and callback `fn(err)`. + * + * @param {Function} fn + * @api private + */ + +Runner.prototype.runTest = function(fn){ + var test = this.test + , self = this; + + if (this.asyncOnly) test.asyncOnly = true; + + try { + test.on('error', function(err){ + self.fail(test, err); + }); + test.run(fn); + } catch (err) { + fn(err); + } +}; + +/** + * Run tests in the given `suite` and invoke + * the callback `fn()` when complete. + * + * @param {Suite} suite + * @param {Function} fn + * @api private + */ + +Runner.prototype.runTests = function(suite, fn){ + var self = this + , tests = suite.tests.slice() + , test; + + function next(err) { + // if we bail after first err + if (self.failures && suite._bail) return fn(); + + // next test + test = tests.shift(); + + // all done + if (!test) return fn(); + + // grep + var match = self._grep.test(test.fullTitle()); + if (self._invert) match = !match; + if (!match) return next(); + + // pending + if (test.pending) { + self.emit('pending', test); + self.emit('test end', test); + return next(); + } + + // execute test and hook(s) + self.emit('test', self.test = test); + self.hookDown('beforeEach', function(){ + self.currentRunnable = self.test; + self.runTest(function(err){ + test = self.test; + + if (err) { + self.fail(test, err); + self.emit('test end', test); + return self.hookUp('afterEach', next); + } + + test.state = 'passed'; + self.emit('pass', test); + self.emit('test end', test); + self.hookUp('afterEach', next); + }); + }); + } + + this.next = next; + next(); +}; + +/** + * Run the given `suite` and invoke the + * callback `fn()` when complete. + * + * @param {Suite} suite + * @param {Function} fn + * @api private + */ + +Runner.prototype.runSuite = function(suite, fn){ + var total = this.grepTotal(suite) + , self = this + , i = 0; + + debug('run suite %s', suite.fullTitle()); + + if (!total) return fn(); + + this.emit('suite', this.suite = suite); + + function next() { + var curr = suite.suites[i++]; + if (!curr) return done(); + self.runSuite(curr, next); + } + + function done() { + self.suite = suite; + self.hook('afterAll', function(){ + self.emit('suite end', suite); + fn(); + }); + } + + this.hook('beforeAll', function(){ + self.runTests(suite, next); + }); +}; + +/** + * Handle uncaught exceptions. + * + * @param {Error} err + * @api private + */ + +Runner.prototype.uncaught = function(err){ + debug('uncaught exception %s', err.message); + var runnable = this.currentRunnable; + if (!runnable || 'failed' == runnable.state) return; + runnable.clearTimeout(); + err.uncaught = true; + this.fail(runnable, err); + + // recover from test + if ('test' == runnable.type) { + this.emit('test end', runnable); + this.hookUp('afterEach', this.next); + return; + } + + // bail on hooks + this.emit('end'); +}; + +/** + * Run the root suite and invoke `fn(failures)` + * on completion. + * + * @param {Function} fn + * @return {Runner} for chaining + * @api public + */ + +Runner.prototype.run = function(fn){ + var self = this + , fn = fn || function(){}; + + function uncaught(err){ + self.uncaught(err); + } + + debug('start'); + + // callback + this.on('end', function(){ + debug('end'); + process.removeListener('uncaughtException', uncaught); + fn(self.failures); + }); + + // run suites + this.emit('start'); + this.runSuite(this.suite, function(){ + debug('finished running'); + self.emit('end'); + }); + + // uncaught exception + process.on('uncaughtException', uncaught); + + return this; +}; + +/** + * Filter leaks with the given globals flagged as `ok`. + * + * @param {Array} ok + * @param {Array} globals + * @return {Array} + * @api private + */ + +function filterLeaks(ok, globals) { + return filter(globals, function(key){ + // Firefox and Chrome exposes iframes as index inside the window object + if (/^d+/.test(key)) return false; + + // in firefox + // if runner runs in an iframe, this iframe's window.getInterface method not init at first + // it is assigned in some seconds + if (global.navigator && /^getInterface/.test(key)) return false; + + // an iframe could be approached by window[iframeIndex] + // in ie6,7,8 and opera, iframeIndex is enumerable, this could cause leak + if (global.navigator && /^\d+/.test(key)) return false; + + // Opera and IE expose global variables for HTML element IDs (issue #243) + if (/^mocha-/.test(key)) return false; + + var matched = filter(ok, function(ok){ + if (~ok.indexOf('*')) return 0 == key.indexOf(ok.split('*')[0]); + return key == ok; + }); + return matched.length == 0 && (!global.navigator || 'onerror' !== key); + }); +} + +}); // module: runner.js + +require.register("suite.js", function(module, exports, require){ + +/** + * Module dependencies. + */ + +var EventEmitter = require('browser/events').EventEmitter + , debug = require('browser/debug')('mocha:suite') + , milliseconds = require('./ms') + , utils = require('./utils') + , Hook = require('./hook'); + +/** + * Expose `Suite`. + */ + +exports = module.exports = Suite; + +/** + * Create a new `Suite` with the given `title` + * and parent `Suite`. When a suite with the + * same title is already present, that suite + * is returned to provide nicer reporter + * and more flexible meta-testing. + * + * @param {Suite} parent + * @param {String} title + * @return {Suite} + * @api public + */ + +exports.create = function(parent, title){ + var suite = new Suite(title, parent.ctx); + suite.parent = parent; + if (parent.pending) suite.pending = true; + title = suite.fullTitle(); + parent.addSuite(suite); + return suite; +}; + +/** + * Initialize a new `Suite` with the given + * `title` and `ctx`. + * + * @param {String} title + * @param {Context} ctx + * @api private + */ + +function Suite(title, ctx) { + this.title = title; + this.ctx = ctx; + this.suites = []; + this.tests = []; + this.pending = false; + this._beforeEach = []; + this._beforeAll = []; + this._afterEach = []; + this._afterAll = []; + this.root = !title; + this._timeout = 2000; + this._slow = 75; + this._bail = false; +} + +/** + * Inherit from `EventEmitter.prototype`. + */ + +function F(){}; +F.prototype = EventEmitter.prototype; +Suite.prototype = new F; +Suite.prototype.constructor = Suite; + + +/** + * Return a clone of this `Suite`. + * + * @return {Suite} + * @api private + */ + +Suite.prototype.clone = function(){ + var suite = new Suite(this.title); + debug('clone'); + suite.ctx = this.ctx; + suite.timeout(this.timeout()); + suite.slow(this.slow()); + suite.bail(this.bail()); + return suite; +}; + +/** + * Set timeout `ms` or short-hand such as "2s". + * + * @param {Number|String} ms + * @return {Suite|Number} for chaining + * @api private + */ + +Suite.prototype.timeout = function(ms){ + if (0 == arguments.length) return this._timeout; + if ('string' == typeof ms) ms = milliseconds(ms); + debug('timeout %d', ms); + this._timeout = parseInt(ms, 10); + return this; +}; + +/** + * Set slow `ms` or short-hand such as "2s". + * + * @param {Number|String} ms + * @return {Suite|Number} for chaining + * @api private + */ + +Suite.prototype.slow = function(ms){ + if (0 === arguments.length) return this._slow; + if ('string' == typeof ms) ms = milliseconds(ms); + debug('slow %d', ms); + this._slow = ms; + return this; +}; + +/** + * Sets whether to bail after first error. + * + * @parma {Boolean} bail + * @return {Suite|Number} for chaining + * @api private + */ + +Suite.prototype.bail = function(bail){ + if (0 == arguments.length) return this._bail; + debug('bail %s', bail); + this._bail = bail; + return this; +}; + +/** + * Run `fn(test[, done])` before running tests. + * + * @param {Function} fn + * @return {Suite} for chaining + * @api private + */ + +Suite.prototype.beforeAll = function(fn){ + if (this.pending) return this; + var hook = new Hook('"before all" hook', fn); + hook.parent = this; + hook.timeout(this.timeout()); + hook.slow(this.slow()); + hook.ctx = this.ctx; + this._beforeAll.push(hook); + this.emit('beforeAll', hook); + return this; +}; + +/** + * Run `fn(test[, done])` after running tests. + * + * @param {Function} fn + * @return {Suite} for chaining + * @api private + */ + +Suite.prototype.afterAll = function(fn){ + if (this.pending) return this; + var hook = new Hook('"after all" hook', fn); + hook.parent = this; + hook.timeout(this.timeout()); + hook.slow(this.slow()); + hook.ctx = this.ctx; + this._afterAll.push(hook); + this.emit('afterAll', hook); + return this; +}; + +/** + * Run `fn(test[, done])` before each test case. + * + * @param {Function} fn + * @return {Suite} for chaining + * @api private + */ + +Suite.prototype.beforeEach = function(fn){ + if (this.pending) return this; + var hook = new Hook('"before each" hook', fn); + hook.parent = this; + hook.timeout(this.timeout()); + hook.slow(this.slow()); + hook.ctx = this.ctx; + this._beforeEach.push(hook); + this.emit('beforeEach', hook); + return this; +}; + +/** + * Run `fn(test[, done])` after each test case. + * + * @param {Function} fn + * @return {Suite} for chaining + * @api private + */ + +Suite.prototype.afterEach = function(fn){ + if (this.pending) return this; + var hook = new Hook('"after each" hook', fn); + hook.parent = this; + hook.timeout(this.timeout()); + hook.slow(this.slow()); + hook.ctx = this.ctx; + this._afterEach.push(hook); + this.emit('afterEach', hook); + return this; +}; + +/** + * Add a test `suite`. + * + * @param {Suite} suite + * @return {Suite} for chaining + * @api private + */ + +Suite.prototype.addSuite = function(suite){ + suite.parent = this; + suite.timeout(this.timeout()); + suite.slow(this.slow()); + suite.bail(this.bail()); + this.suites.push(suite); + this.emit('suite', suite); + return this; +}; + +/** + * Add a `test` to this suite. + * + * @param {Test} test + * @return {Suite} for chaining + * @api private + */ + +Suite.prototype.addTest = function(test){ + test.parent = this; + test.timeout(this.timeout()); + test.slow(this.slow()); + test.ctx = this.ctx; + this.tests.push(test); + this.emit('test', test); + return this; +}; + +/** + * Return the full title generated by recursively + * concatenating the parent's full title. + * + * @return {String} + * @api public + */ + +Suite.prototype.fullTitle = function(){ + if (this.parent) { + var full = this.parent.fullTitle(); + if (full) return full + ' ' + this.title; + } + return this.title; +}; + +/** + * Return the total number of tests. + * + * @return {Number} + * @api public + */ + +Suite.prototype.total = function(){ + return utils.reduce(this.suites, function(sum, suite){ + return sum + suite.total(); + }, 0) + this.tests.length; +}; + +/** + * Iterates through each suite recursively to find + * all tests. Applies a function in the format + * `fn(test)`. + * + * @param {Function} fn + * @return {Suite} + * @api private + */ + +Suite.prototype.eachTest = function(fn){ + utils.forEach(this.tests, fn); + utils.forEach(this.suites, function(suite){ + suite.eachTest(fn); + }); + return this; +}; + +}); // module: suite.js + +require.register("test.js", function(module, exports, require){ + +/** + * Module dependencies. + */ + +var Runnable = require('./runnable'); + +/** + * Expose `Test`. + */ + +module.exports = Test; + +/** + * Initialize a new `Test` with the given `title` and callback `fn`. + * + * @param {String} title + * @param {Function} fn + * @api private + */ + +function Test(title, fn) { + Runnable.call(this, title, fn); + this.pending = !fn; + this.type = 'test'; +} + +/** + * Inherit from `Runnable.prototype`. + */ + +function F(){}; +F.prototype = Runnable.prototype; +Test.prototype = new F; +Test.prototype.constructor = Test; + + +}); // module: test.js + +require.register("utils.js", function(module, exports, require){ +/** + * Module dependencies. + */ + +var fs = require('browser/fs') + , path = require('browser/path') + , join = path.join + , debug = require('browser/debug')('mocha:watch'); + +/** + * Ignored directories. + */ + +var ignore = ['node_modules', '.git']; + +/** + * Escape special characters in the given string of html. + * + * @param {String} html + * @return {String} + * @api private + */ + +exports.escape = function(html){ + return String(html) + .replace(/&/g, '&') + .replace(/"/g, '"') + .replace(//g, '>'); +}; + +/** + * Array#forEach (<=IE8) + * + * @param {Array} array + * @param {Function} fn + * @param {Object} scope + * @api private + */ + +exports.forEach = function(arr, fn, scope){ + for (var i = 0, l = arr.length; i < l; i++) + fn.call(scope, arr[i], i); +}; + +/** + * Array#indexOf (<=IE8) + * + * @parma {Array} arr + * @param {Object} obj to find index of + * @param {Number} start + * @api private + */ + +exports.indexOf = function(arr, obj, start){ + for (var i = start || 0, l = arr.length; i < l; i++) { + if (arr[i] === obj) + return i; + } + return -1; +}; + +/** + * Array#reduce (<=IE8) + * + * @param {Array} array + * @param {Function} fn + * @param {Object} initial value + * @api private + */ + +exports.reduce = function(arr, fn, val){ + var rval = val; + + for (var i = 0, l = arr.length; i < l; i++) { + rval = fn(rval, arr[i], i, arr); + } + + return rval; +}; + +/** + * Array#filter (<=IE8) + * + * @param {Array} array + * @param {Function} fn + * @api private + */ + +exports.filter = function(arr, fn){ + var ret = []; + + for (var i = 0, l = arr.length; i < l; i++) { + var val = arr[i]; + if (fn(val, i, arr)) ret.push(val); + } + + return ret; +}; + +/** + * Object.keys (<=IE8) + * + * @param {Object} obj + * @return {Array} keys + * @api private + */ + +exports.keys = Object.keys || function(obj) { + var keys = [] + , has = Object.prototype.hasOwnProperty // for `window` on <=IE8 + + for (var key in obj) { + if (has.call(obj, key)) { + keys.push(key); + } + } + + return keys; +}; + +/** + * Watch the given `files` for changes + * and invoke `fn(file)` on modification. + * + * @param {Array} files + * @param {Function} fn + * @api private + */ + +exports.watch = function(files, fn){ + var options = { interval: 100 }; + files.forEach(function(file){ + debug('file %s', file); + fs.watchFile(file, options, function(curr, prev){ + if (prev.mtime < curr.mtime) fn(file); + }); + }); +}; + +/** + * Ignored files. + */ + +function ignored(path){ + return !~ignore.indexOf(path); +} + +/** + * Lookup files in the given `dir`. + * + * @return {Array} + * @api private + */ + +exports.files = function(dir, ret){ + ret = ret || []; + + fs.readdirSync(dir) + .filter(ignored) + .forEach(function(path){ + path = join(dir, path); + if (fs.statSync(path).isDirectory()) { + exports.files(path, ret); + } else if (path.match(/\.(js|coffee|litcoffee|coffee.md)$/)) { + ret.push(path); + } + }); + + return ret; +}; + +/** + * Compute a slug from the given `str`. + * + * @param {String} str + * @return {String} + * @api private + */ + +exports.slug = function(str){ + return str + .toLowerCase() + .replace(/ +/g, '-') + .replace(/[^-\w]/g, ''); +}; + +/** + * Strip the function definition from `str`, + * and re-indent for pre whitespace. + */ + +exports.clean = function(str) { + str = str + .replace(/^function *\(.*\) *{/, '') + .replace(/\s+\}$/, ''); + + var whitespace = str.match(/^\n?(\s*)/)[1] + , re = new RegExp('^' + whitespace, 'gm'); + + str = str.replace(re, ''); + + return exports.trim(str); +}; + +/** + * Escape regular expression characters in `str`. + * + * @param {String} str + * @return {String} + * @api private + */ + +exports.escapeRegexp = function(str){ + return str.replace(/[-\\^$*+?.()|[\]{}]/g, "\\$&"); +}; + +/** + * Trim the given `str`. + * + * @param {String} str + * @return {String} + * @api private + */ + +exports.trim = function(str){ + return str.replace(/^\s+|\s+$/g, ''); +}; + +/** + * Parse the given `qs`. + * + * @param {String} qs + * @return {Object} + * @api private + */ + +exports.parseQuery = function(qs){ + return exports.reduce(qs.replace('?', '').split('&'), function(obj, pair){ + var i = pair.indexOf('=') + , key = pair.slice(0, i) + , val = pair.slice(++i); + + obj[key] = decodeURIComponent(val); + return obj; + }, {}); +}; + +/** + * Highlight the given string of `js`. + * + * @param {String} js + * @return {String} + * @api private + */ + +function highlight(js) { + return js + .replace(//g, '>') + .replace(/\/\/(.*)/gm, '//$1') + .replace(/('.*?')/gm, '$1') + .replace(/(\d+\.\d+)/gm, '$1') + .replace(/(\d+)/gm, '$1') + .replace(/\bnew *(\w+)/gm, 'new $1') + .replace(/\b(function|new|throw|return|var|if|else)\b/gm, '$1') +} + +/** + * Highlight the contents of tag `name`. + * + * @param {String} name + * @api private + */ + +exports.highlightTags = function(name) { + var code = document.getElementsByTagName(name); + for (var i = 0, len = code.length; i < len; ++i) { + code[i].innerHTML = highlight(code[i].innerHTML); + } +}; + +}); // module: utils.js +// The global object is "self" in Web Workers. +global = (function() { return this; })(); + +/** + * Save timer references to avoid Sinon interfering (see GH-237). + */ + +var Date = global.Date; +var setTimeout = global.setTimeout; +var setInterval = global.setInterval; +var clearTimeout = global.clearTimeout; +var clearInterval = global.clearInterval; + +/** + * Node shims. + * + * These are meant only to allow + * mocha.js to run untouched, not + * to allow running node code in + * the browser. + */ + +var process = {}; +process.exit = function(status){}; +process.stdout = {}; + +/** + * Remove uncaughtException listener. + */ + +process.removeListener = function(e){ + if ('uncaughtException' == e) { + global.onerror = function() {}; + } +}; + +/** + * Implements uncaughtException listener. + */ + +process.on = function(e, fn){ + if ('uncaughtException' == e) { + global.onerror = function(err, url, line){ + fn(new Error(err + ' (' + url + ':' + line + ')')); + }; + } +}; + +/** + * Expose mocha. + */ + +var Mocha = global.Mocha = require('mocha'), + mocha = global.mocha = new Mocha({ reporter: 'html' }); + +var immediateQueue = [] + , immediateTimeout; + +function timeslice() { + var immediateStart = new Date().getTime(); + while (immediateQueue.length && (new Date().getTime() - immediateStart) < 100) { + immediateQueue.shift()(); + } + if (immediateQueue.length) { + immediateTimeout = setTimeout(timeslice, 0); + } else { + immediateTimeout = null; + } +} + +/** + * High-performance override of Runner.immediately. + */ + +Mocha.Runner.immediately = function(callback) { + immediateQueue.push(callback); + if (!immediateTimeout) { + immediateTimeout = setTimeout(timeslice, 0); + } +}; + +/** + * Override ui to ensure that the ui functions are initialized. + * Normally this would happen in Mocha.prototype.loadFiles. + */ + +mocha.ui = function(ui){ + Mocha.prototype.ui.call(this, ui); + this.suite.emit('pre-require', global, null, this); + return this; +}; + +/** + * Setup mocha with the given setting options. + */ + +mocha.setup = function(opts){ + if ('string' == typeof opts) opts = { ui: opts }; + for (var opt in opts) this[opt](opts[opt]); + return this; +}; + +/** + * Run mocha, returning the Runner. + */ + +mocha.run = function(fn){ + var options = mocha.options; + mocha.globals('location'); + + var query = Mocha.utils.parseQuery(global.location.search || ''); + if (query.grep) mocha.grep(query.grep); + if (query.invert) mocha.invert(); + + return Mocha.prototype.run.call(mocha, function(){ + // The DOM Document is not available in Web Workers. + if (global.document) { + Mocha.utils.highlightTags('code'); + } + if (fn) fn(); + }); +}; + +/** + * Expose the process shim. + */ + +Mocha.process = process; +})(); diff --git a/test/server/post-message.jade b/test/server/post-message.jade new file mode 100644 index 000000000..e14852998 --- /dev/null +++ b/test/server/post-message.jade @@ -0,0 +1,57 @@ +doctype html +html + script. + (function (window) { + + try { + post(!{JSON.stringify(message)}); + } catch (err) { + report(err); + } finally { + done(); + } + + function post (msg) { + if (isIE()) { + var relay = findRelay('recurly_relay'); + if (!relay) throw new Error('relay not found'); + relay.send(msg, '*'); + } else { + window.opener.postMessage(msg, '*'); + } + } + + function isIE () { + var nav = window.navigator; + return nav.appName == 'Microsoft Internet Explorer' + || nav.userAgent.indexOf('Trident') > -1; + } + + function findRelay (name) { + var loc = window.location; + var origin = loc.protocol + '//' + loc.host; + var frames = window.opener.frames; + + for (var i = 0; i < frames.length; i++) { + try { + var frame = frames[i]; + if (0 === frame.location.href.indexOf(origin)) { + if (name === frame.name) { + return frame; + } + } + } catch (e) { + // missing location, cross-origin + } + } + } + + function done () { + window.close(); + } + + function report (err) { + // TODO: report somewhere... + } + + })(window); diff --git a/test/server/relay.jade b/test/server/relay.jade new file mode 100644 index 000000000..e4aff8a46 --- /dev/null +++ b/test/server/relay.jade @@ -0,0 +1,9 @@ +doctype html +html + head + script. + window.relay = function (msg, origin) { + window.setTimeout(function () { + window.postMessage(msg, origin); + }, 0); + }; diff --git a/test/unit/configure.test.js b/test/unit/configure.test.js new file mode 100644 index 000000000..076818271 --- /dev/null +++ b/test/unit/configure.test.js @@ -0,0 +1,79 @@ + +var assert = require('assert'); +var each = require('each'); +var bind = require('bind'); +var sinon = require('sinon'); + +describe('Recurly.configure', function () { + var Recurly = window.recurly.Recurly; + var recurly; + + beforeEach(function () { + recurly = new Recurly(); + }); + + describe('when options.publicKey is not given', function () { + var examples = [ + {} + , { invalid: 'parameter' } + , { currency: 'USD' } + , { currency: 'AUD', api: 'https://localhost' } + ]; + + it('throws', function () { + each(examples, function (opts) { + assert.throws(bind(recurly, recurly.configure, opts)); + }); + }); + + it('Recurly.configured remains false', function () { + each(examples, function (opts) { + try { + recurly.configure(opts); + } catch (e) { + assert(recurly.configured === false); + } + }); + }); + }); + + describe('when options.publicKey is given', function () { + var examples = [ + { publicKey: 'foo' } + , { publicKey: 'foo', currency: 'USD' } + , { publicKey: 'foo', currency: 'AUD', api: 'https://localhost' } + ]; + + it('sets Recurly.config to the options given', function () { + each(examples, function (opts) { + var recurly = new Recurly(); + recurly.configure(opts); + each(opts, function (opt, val) { + assert(recurly.config[opt] === val); + }); + }); + }); + + it('sets default values for options not given', function () { + each(examples, function (opts) { + var recurly = new Recurly(); + recurly.configure(opts); + each(recurly.config, function (option, val) { + if (opts[option]) { + assert(opts[option] === val); + } else { + assert(val !== undefined); + assert(val !== opts[option]); + } + }); + }); + }); + + describe('when options.api is given', function () { + it('sets Recurly.config.api to the given api', function () { + recurly.configure({ publicKey: 'foo', api: 'http://localhost' }); + assert(recurly.config.api === 'http://localhost'); + }); + }); + }); +}); diff --git a/test/unit/coupon.test.js b/test/unit/coupon.test.js new file mode 100644 index 000000000..978daad13 --- /dev/null +++ b/test/unit/coupon.test.js @@ -0,0 +1,57 @@ + +var assert = require('assert'); +var each = require('each'); +var sinon = require('sinon'); +var noop = require('noop'); + +describe('Recurly.coupon', function () { + var Recurly = window.recurly.Recurly; + var valid = { plan: 'basic', coupon: 'coop' }; + var invalidPlan = { plan: 'invalid', coupon: 'coop' }; + var invalidCoupon = { plan: 'basic', coupon: 'invalid' }; + var recurly; + + beforeEach(function () { + recurly = new Recurly(); + recurly.configure({ + publicKey: 'test', + api: 'http://' + window.location.host + }); + }); + + it('requires a callback', function () { + try { + recurly.coupon(valid); + } catch (e) { + assert(~e.message.indexOf('callback')); + } + }); + + it('requires Recurly.configure', function () { + try { + recurly = new Recurly(); + recurly.coupon(valid, noop); + } catch (e) { + assert(e); + } + }); + + describe('when given an invalid plan', function () { + it('produces an error', function (done) { + recurly.coupon({ plan: 'invalid', coupon: 'coop' }, function (err) { + assert(err); + done(); + }); + }); + }); + + describe('when given a valid plan', function () { + describe('when given an invalid coupon', function () { + it('should throw an error'); + }); + + describe('when given a valid coupon', function () { + it('should fetch them from the api'); + }); + }); +}); diff --git a/test/unit/open.test.js b/test/unit/open.test.js new file mode 100644 index 000000000..b547d95c2 --- /dev/null +++ b/test/unit/open.test.js @@ -0,0 +1,124 @@ + +var assert = require('assert'); +var each = require('each'); +var noop = require('noop'); +var qs = require('querystring'); +var sinon = require('sinon'); + +describe('Recurly.open', function () { + var Recurly = window.recurly.Recurly; + var exampleUrl = 'http://recurly.com'; + var exampleData = { example: 'data' }; + var recurly; + + beforeEach(function () { + recurly = new Recurly; + recurly.configure({ + publicKey: 'test', + api: 'http://' + window.location.host + }); + sinon.stub(window, 'open'); + }); + + afterEach(function () { + window.open.restore(); + }); + + it('requires Recurly.configure', function () { + try { + recurly.open(exampleUrl); + } catch (e) { + assert(~e.message.indexOf('Recurly.configure')); + } + }); + + it('accepts a callback as either second or third parameter', function () { + recurly.open(exampleUrl, noop); + recurly.open(exampleUrl, {}, noop); + }); + + it('calls window.open', function () { + recurly.open(exampleUrl, noop); + assert(window.open.calledOnce); + }); + + it('sends Recurly.version in the url', function () { + recurly.open(exampleUrl); + assert(window.open.calledWithMatch('version=' + recurly.version)); + }); + + it('sends a listener event name to the opened url', function () { + recurly.open(exampleUrl); + assert(window.open.calledWithMatch(/recurly-open-\d+/)); + }); + + it('attaches an event listener to Recurly', function () { + var eventName; + window.open.restore(); + sinon.stub(window, 'open', function (url) { + eventName = url.match(/(recurly-open-\d+)/)[0]; + }); + recurly.open(exampleUrl); + assert(recurly.hasListeners(eventName)); + }); + + describe('when given a url with a protocol', function () { + var examples = [ + 'http://google.com' + , 'https://google.com' + ]; + + it('opens that url', function () { + each(examples, function (example) { + recurly.open(example); + assert(window.open.calledWithMatch(example)); + }); + }); + }); + + describe('when given a url without a protocol', function () { + var examples = [ + '/paypal/start' + , 'google.com' + , 'bfjbkdfs' + ]; + + it('opens the url relative to Recurly.config.api', function () { + each(examples, function (example) { + var expectation = recurly.config.api + example; + recurly.open(example); + assert(window.open.calledWithMatch(expectation)); + }); + }); + }); + + describe('when given data', function () { + it('encodes the data into the opener url', function () { + recurly.open(exampleUrl, exampleData); + assert(window.open.calledWithMatch('example=data')); + }); + + it('produces a valid composite querystring of given and additional data', function () { + recurly.open(exampleUrl, exampleData); + assert(window.open.calledWithMatch(function (url) { + return (url.match(/\?/) || []).length; + })); + }); + }); + + describe('when given a callback', function () { + var callback = sinon.stub(); + + it('is called when the event is emitted', function () { + var eventName; + window.open.restore(); + sinon.stub(window, 'open', function (url) { + eventName = url.match(/(recurly-open-\d+)/)[0]; + }); + recurly.open(exampleUrl, callback); + recurly.emit(eventName, exampleData); + assert(callback.calledOnce); + assert(callback.calledWith(exampleData)); + }); + }); +}); diff --git a/test/unit/recurly.test.js b/test/unit/recurly.test.js new file mode 100644 index 000000000..a4c45e0ca --- /dev/null +++ b/test/unit/recurly.test.js @@ -0,0 +1,23 @@ + +var assert = require('assert'); + +describe('Recurly', function () { + var Recurly = window.recurly.Recurly; + var recurly; + + beforeEach(function () { + recurly = new Recurly(); + }); + + it('should have a version', function () { + assert('string' === typeof recurly.version); + }); + + it('should be an event emitter', function () { + assert(recurly.on && recurly.emit); + }); + + it('should be exposed as a global singleton', function () { + assert(window.recurly instanceof Recurly); + }); +}); diff --git a/test/unit/request.test.js b/test/unit/request.test.js new file mode 100644 index 000000000..e69de29bb