konacha-chai-matchers 0.0.1

data/vendor/assets/javascripts/chai-backbone.js

@@ -0,0 +1,101 @@
+(function() {
+
+  (function(chaiBackbone) {
+    if (typeof require === "function" && typeof exports === "object" && typeof module === "object") {
+      return module.exports = chaiBackbone;
+    } else if (typeof define === "function" && define.amd) {
+      return define(function() {
+        return chaiBackbone;
+      });
+    } else {
+      return chai.use(chaiBackbone);
+    }
+  })(function(chai, utils) {
+    var flag, inspect, routeTo;
+    inspect = utils.inspect;
+    flag = utils.flag;
+    chai.Assertion.addMethod('trigger', function(trigger, options) {
+      var definedActions;
+      if (options == null) options = {};
+      definedActions = flag(this, 'whenActions') || [];
+      definedActions.push({
+        negate: flag(this, 'negate'),
+        before: function(context) {
+          this.callback = sinon.spy();
+          return flag(context, 'object').on(trigger, this.callback);
+        },
+        after: function(context) {
+          var negate, _ref;
+          negate = flag(context, 'negate');
+          flag(context, 'negate', this.negate);
+          context.assert(this.callback.calledOnce, "expected to trigger " + trigger, "expected not to trigger " + trigger);
+          if (options["with"] != null) {
+            context.assert((_ref = this.callback).calledWith.apply(_ref, options["with"]), "expected trigger to be called with " + (inspect(options["with"])) + ", but was called with " + (inspect(this.callback.args[0])) + ".", "expected trigger not to be called with " + (inspect(options["with"])) + ", but was");
+          }
+          return flag(context, 'negate', negate);
+        }
+      });
+      return flag(this, 'whenActions', definedActions);
+    });
+    chai.Assertion.addProperty('route', function() {
+      return flag(this, 'routing', true);
+    });
+    routeTo = function(router, methodName, options) {
+      var consideredRouter, current_history, route, spy, _i, _len, _ref;
+      if (options == null) options = {};
+      current_history = Backbone.history;
+      Backbone.history = new Backbone.History;
+      spy = sinon.spy(router, methodName);
+      this.assert(router._bindRoutes != null, 'provided router is not a Backbone.Router');
+      router._bindRoutes();
+      if (options.considering != null) {
+        _ref = options.considering;
+        for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+          consideredRouter = _ref[_i];
+          consideredRouter._bindRoutes();
+        }
+      }
+      Backbone.history.options = {
+        root: '/'
+      };
+      route = flag(this, 'object');
+      Backbone.history.loadUrl(route);
+      Backbone.history = current_history;
+      router[methodName].restore();
+      this.assert(spy.calledOnce, "expected `" + route + "` to route to " + methodName, "expected `" + route + "` not to route to " + methodName);
+      if (options.arguments != null) {
+        return this.assert(spy.calledWith.apply(spy, options.arguments), "expected `" + methodName + "` to be called with " + (inspect(options.arguments)) + ", but was called with " + (inspect(spy.args[0])) + " instead", "expected `" + methodName + "` not to be called with " + (inspect(options.arguments)) + ", but was");
+      }
+    };
+    chai.Assertion.overwriteProperty('to', function(_super) {
+      return function() {
+        if (flag(this, 'routing')) {
+          return routeTo;
+        } else {
+          return _super.apply(this, arguments);
+        }
+      };
+    });
+    return chai.Assertion.addMethod('call', function(methodName) {
+      var definedActions, object;
+      object = flag(this, 'object');
+      definedActions = flag(this, 'whenActions') || [];
+      definedActions.push({
+        negate: flag(this, 'negate'),
+        before: function(context) {
+          this.originalMethod = object[methodName];
+          this.spy = sinon.spy();
+          object[methodName] = this.spy;
+          return typeof object.delegateEvents === "function" ? object.delegateEvents() : void 0;
+        },
+        after: function(context) {
+          object[methodName] = this.originalMethod;
+          if (typeof object.delegateEvents === "function") object.delegateEvents();
+          return context.assert(this.spy.callCount > 0, this.spy.printf("expected %n to have been called at least once"), this.spy.printf("expected %n to not have been called"));
+        }
+      });
+      return flag(this, 'whenActions', definedActions);
+    });
+  });
+
+}).call(this);

data/vendor/assets/javascripts/chai-changes.js

@@ -0,0 +1,173 @@
+(function(chaiChanges) {
+  if (typeof require === "function" && typeof exports === "object" && typeof module === "object") {
+    return module.exports = chaiChanges;
+  } else if (typeof define === "function" && define.amd) {
+    return define(function() {
+      return chaiChanges;
+    });
+  } else {
+    return chai.use(chaiChanges);
+  }
+})(function(chai, utils) {
+  var changeBy, changeByAssert, changeFrom, changeFromAssert, changeFromBeginAssert, changeTo, changeToAssert, changeToBeginAssert, flag, formatFunction, inspect, noChangeAssert;
+  inspect = utils.inspect;
+  flag = utils.flag;
+  /*
+    #
+    # Changes Matchers
+    #
+  */
+
+  chai.Assertion.addMethod('when', function(val) {
+    var action, definedActions, _i, _j, _len, _len1, _results;
+    definedActions = flag(this, 'whenActions') || [];
+    for (_i = 0, _len = definedActions.length; _i < _len; _i++) {
+      action = definedActions[_i];
+      if (typeof action.before === "function") {
+        action.before(this);
+      }
+    }
+    val();
+    _results = [];
+    for (_j = 0, _len1 = definedActions.length; _j < _len1; _j++) {
+      action = definedActions[_j];
+      _results.push(typeof action.after === "function" ? action.after(this) : void 0);
+    }
+    return _results;
+  });
+  noChangeAssert = function(context) {
+    var endValue, negate, object, relevant, result, startValue;
+    relevant = flag(context, 'no-change');
+    if (!relevant) {
+      return;
+    }
+    negate = flag(context, 'negate');
+    flag(context, 'negate', this.negate);
+    object = flag(context, 'object');
+    startValue = flag(context, 'changeStart');
+    endValue = object();
+    result = !utils.eql(endValue, startValue);
+    context.assert(result, "expected `" + (formatFunction(object)) + "` to change, but it stayed " + (utils.inspect(startValue)), "expected `" + (formatFunction(object)) + "` not to change, but it changed from " + (utils.inspect(startValue)) + " to " + (utils.inspect(endValue)));
+    return flag(context, 'negate', negate);
+  };
+  changeByAssert = function(context) {
+    var actualDelta, endValue, negate, object, startValue;
+    negate = flag(context, 'negate');
+    flag(context, 'negate', this.negate);
+    object = flag(context, 'object');
+    startValue = flag(context, 'changeStart');
+    endValue = object();
+    actualDelta = endValue - startValue;
+    context.assert(this.expectedDelta === actualDelta, "expected `" + (formatFunction(object)) + "` to change by " + this.expectedDelta + ", but it changed by " + actualDelta, "expected `" + (formatFunction(object)) + "` not to change by " + this.expectedDelta + ", but it did");
+    return flag(context, 'negate', negate);
+  };
+  changeToBeginAssert = function(context) {
+    var negate, object, result, startValue;
+    negate = flag(context, 'negate');
+    flag(context, 'negate', this.negate);
+    object = flag(context, 'object');
+    startValue = object();
+    result = !utils.eql(startValue, this.expectedEndValue);
+    if (negate) {
+      result = !result;
+    }
+    context.assert(result, "expected `" + (formatFunction(object)) + "` to change to " + (utils.inspect(this.expectedEndValue)) + ", but it was already " + (utils.inspect(startValue)), "not supported");
+    return flag(context, 'negate', negate);
+  };
+  changeToAssert = function(context) {
+    var endValue, negate, object, result;
+    negate = flag(context, 'negate');
+    flag(context, 'negate', this.negate);
+    object = flag(context, 'object');
+    endValue = object();
+    result = utils.eql(endValue, this.expectedEndValue);
+    context.assert(result, "expected `" + (formatFunction(object)) + "` to change to " + (utils.inspect(this.expectedEndValue)) + ", but it changed to " + (utils.inspect(endValue)), "expected `" + (formatFunction(object)) + "` not to change to " + (utils.inspect(this.expectedEndValue)) + ", but it did");
+    return flag(context, 'negate', negate);
+  };
+  changeFromBeginAssert = function(context) {
+    var negate, object, result, startValue;
+    negate = flag(context, 'negate');
+    flag(context, 'negate', this.negate);
+    object = flag(context, 'object');
+    startValue = object();
+    result = utils.eql(startValue, this.expectedStartValue);
+    context.assert(result, "expected the change of `" + (formatFunction(object)) + "` to start from " + (utils.inspect(this.expectedStartValue)) + ", but it started from " + (utils.inspect(startValue)), "expected the change of `" + (formatFunction(object)) + "` not to start from " + (utils.inspect(this.expectedStartValue)) + ", but it did");
+    return flag(context, 'negate', negate);
+  };
+  changeFromAssert = function(context) {
+    var endValue, negate, object, result, startValue;
+    negate = flag(context, 'negate');
+    flag(context, 'negate', this.negate);
+    object = flag(context, 'object');
+    startValue = flag(context, 'changeStart');
+    endValue = object();
+    result = !utils.eql(startValue, endValue);
+    if (negate) {
+      result = !result;
+    }
+    context.assert(result, "expected `" + (formatFunction(object)) + "` to change from " + (utils.inspect(this.expectedStartValue)) + ", but it did not change", "not supported");
+    return flag(context, 'negate', negate);
+  };
+  chai.Assertion.addProperty('change', function() {
+    var definedActions;
+    flag(this, 'no-change', true);
+    definedActions = flag(this, 'whenActions') || [];
+    definedActions.push({
+      negate: flag(this, 'negate'),
+      before: function(context) {
+        var startValue;
+        startValue = flag(context, 'object')();
+        return flag(context, 'changeStart', startValue);
+      },
+      after: noChangeAssert
+    });
+    return flag(this, 'whenActions', definedActions);
+  });
+  formatFunction = function(func) {
+    return func.toString().replace(/^\s*function \(\) {\s*/, '').replace(/\s+}$/, '').replace(/\s*return\s*/, '');
+  };
+  changeBy = function(delta) {
+    var definedActions;
+    flag(this, 'no-change', false);
+    definedActions = flag(this, 'whenActions') || [];
+    definedActions.push({
+      negate: flag(this, 'negate'),
+      expectedDelta: delta,
+      after: changeByAssert
+    });
+    return flag(this, 'whenActions', definedActions);
+  };
+  chai.Assertion.addChainableMethod('by', changeBy, function() {
+    return this;
+  });
+  changeTo = function(endValue) {
+    var definedActions;
+    flag(this, 'no-change', false);
+    definedActions = flag(this, 'whenActions') || [];
+    definedActions.push({
+      negate: flag(this, 'negate'),
+      expectedEndValue: endValue,
+      before: changeToBeginAssert,
+      after: changeToAssert
+    });
+    return flag(this, 'whenActions', definedActions);
+  };
+  chai.Assertion.addChainableMethod('to', changeTo, function() {
+    return this;
+  });
+  changeFrom = function(startValue) {
+    var definedActions;
+    flag(this, 'no-change', false);
+    definedActions = flag(this, 'whenActions') || [];
+    definedActions.push({
+      negate: flag(this, 'negate'),
+      expectedStartValue: startValue,
+      before: changeFromBeginAssert,
+      after: changeFromAssert
+    });
+    return flag(this, 'whenActions', definedActions);
+  };
+  return chai.Assertion.addChainableMethod('from', changeFrom, function() {
+    return this;
+  });
+});

data/vendor/assets/javascripts/chai-factories.js

@@ -0,0 +1,166 @@
+!function (name, definition) {
+  if (typeof define == 'function' && typeof define.amd  == 'object') define(definition);
+  else this[name] = definition();
+}('chai_factories', 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[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("factories", function (module, exports, require) {
+/*!
+ * chai-null :: Factories over fixtures
+ *
+ * Chai.js Team - http://chaijs.com/
+ * Copyright (c) 2012 Veselin Todorov <hi@vesln.com>
+ *
+ * MIT Licensed
+ */
+
+/**
+ * Extends multiple objects.
+ *
+ * @returns {Object}
+ */
+function extend() {
+  var arr = Array.prototype.slice.call(arguments);
+  var main = arr.length === 2 ? arr.shift() : {};
+
+  arr.forEach(function(obj) {
+    for (var p in obj) {
+      if (!obj.hasOwnProperty(p)) continue;
+      main[p] = obj[p];
+    }
+  });
+
+  return main;
+};
+
+/**
+ * Collector. Store the registered factories.
+ *
+ * @api public
+ */
+function Collector() {
+  this.collection = {};
+};
+
+/**
+ * Register a factory.
+ *
+ * @param {String} name
+ * @param {Factory} factory
+ * @api public
+ */
+Collector.prototype.set = function(name, factory) {
+  this.collection[name] = factory;
+};
+
+/**
+ * Get a factory.
+ *
+ * @param {String} name
+ * @returns {Factory} factory
+ * @api public
+ */
+Collector.prototype.get = function(name) {
+  return this.collection[name];
+};
+
+/**
+ * Factory class.
+ *
+ * @param {Object} attributes
+ * @api public
+ */
+function Factory(attributes) {
+  this.attributes = attributes;
+};
+
+/**
+ * Create a factory.
+ *
+ * @param {Object} attributes
+ * @returns {Object}
+ * @api public
+ */
+Factory.prototype.create = function(attributes) {
+  return extend(extend(this.attributes), attributes);
+};
+
+/**
+ * Extend a factory.
+ *
+ * @param {Object} attributes
+ * @returns {Object}
+ * @api public
+ */
+Factory.prototype.extend = function(attributes) {
+  return this.create(attributes);
+};
+
+/**
+ * Register as plugin.
+ */
+module.exports = function(chai, _) {
+  var collector = new Collector;
+
+  chai.factory = function(name, attributes) {
+    var factory = new Factory(attributes);
+    collector.set(name, factory);
+    return factory;
+  };
+
+  chai.create = function(name, attributes) {
+    var factory = collector.get(name);
+    if (!factory) throw new Error('Unknown factory: ' + name);
+    return factory.create(attributes);
+  };
+};
+
+}); // module factories
+  return require('factories');
+});
+
+chai.use(chai_factories);

data/vendor/assets/javascripts/chai-jquery.js

@@ -0,0 +1,232 @@
+(function (chaiJquery) {
+  // Module systems magic dance.
+  if (typeof require === "function" && typeof exports === "object" && typeof module === "object") {
+    // NodeJS
+    module.exports = chaiJquery;
+  } else if (typeof define === "function" && define.amd) {
+    // AMD
+    define(function () {
+      return chaiJquery;
+    });
+  } else {
+    // Other environment (usually <script> tag): plug in to global chai instance directly.
+    chai.use(chaiJquery);
+  }
+}(function (chai, utils) {
+  var inspect = utils.inspect,
+      flag = utils.flag;
+
+  jQuery.fn.inspect = function (depth) {
+    var el = jQuery('<div />').append(this.clone());
+    if (depth !== undefined) {
+      var children = el.children();
+      while (depth-- > 0)
+        children = children.children();
+      children.html('...');
+    }
+    return el.html();
+  };
+
+  var props = {attr: 'attribute', css: 'CSS property'};
+  for (var prop in props) {
+    (function (prop, description) {
+      chai.Assertion.addMethod(prop, function (name, val) {
+        var actual = flag(this, 'object')[prop](name);
+
+        if (!flag(this, 'negate') || undefined === val) {
+          this.assert(
+              undefined !== actual
+            , 'expected #{this} to have a #{exp} ' + description
+            , 'expected #{this} not to have a #{exp} ' + description
+            , name
+          );
+        }
+
+        if (undefined !== val) {
+          this.assert(
+              val === actual
+            , 'expected #{this} to have a ' + inspect(name) + ' ' + description + ' with the value #{exp}, but the value was #{act}'
+            , 'expected #{this} not to have a ' + inspect(name) + ' ' + description + ' with the value #{act}'
+            , val
+            , actual
+          );
+        }
+
+        flag(this, 'object', actual);
+      });
+    })(prop, props[prop]);
+  }
+
+  chai.Assertion.addMethod('data', function (name, val) {
+    // Work around a chai bug (https://github.com/logicalparadox/chai/issues/16)
+    if (flag(this, 'negate') && undefined !== val && undefined === flag(this, 'object').data(name)) {
+      return;
+    }
+
+    var assertion = new chai.Assertion(flag(this, 'object').data());
+    if (flag(this, 'negate'))
+      assertion = assertion.not;
+    return assertion.property(name, val);
+  });
+
+  chai.Assertion.addMethod('class', function (className) {
+    this.assert(
+        flag(this, 'object').hasClass(className)
+      , 'expected #{this} to have class #{exp}'
+      , 'expected #{this} not to have class #{exp}'
+      , className
+    );
+  });
+
+  chai.Assertion.addMethod('id', function (id) {
+    this.assert(
+        flag(this, 'object').attr('id') === id
+      , 'expected #{this} to have id #{exp}'
+      , 'expected #{this} not to have id #{exp}'
+      , id
+    );
+  });
+
+  chai.Assertion.addMethod('html', function (html) {
+    this.assert(
+        flag(this, 'object').html() === html
+      , 'expected #{this} to have HTML #{exp}'
+      , 'expected #{this} not to have HTML #{exp}'
+      , html
+    );
+  });
+
+  chai.Assertion.addMethod('text', function (text) {
+    this.assert(
+        flag(this, 'object').text() === text
+      , 'expected #{this} to have text #{exp}'
+      , 'expected #{this} not to have text #{exp}'
+      , text
+    );
+  });
+
+  chai.Assertion.addMethod('value', function (value) {
+    this.assert(
+        flag(this, 'object').val() === value
+      , 'expected #{this} to have value #{exp}'
+      , 'expected #{this} not to have value #{exp}'
+      , value
+    );
+  });
+
+  jQuery.each(['visible', 'hidden', 'selected', 'checked', 'disabled'], function (i, attr) {
+    chai.Assertion.addProperty(attr, function () {
+      this.assert(
+          flag(this, 'object').is(':' + attr)
+        , 'expected #{this} to be ' + attr
+        , 'expected #{this} not to be ' + attr);
+    });
+  });
+
+  chai.Assertion.overwriteProperty('exist', function (_super) {
+    return function () {
+      var obj = flag(this, 'object');
+      if (obj instanceof jQuery) {
+        this.assert(
+            obj.length > 0
+          , 'expected ' + inspect(obj.selector) + ' to exist'
+          , 'expected ' + inspect(obj.selector) + ' not to exist');
+      } else {
+        _super.apply(this, arguments);
+      }
+    };
+  });
+
+  chai.Assertion.overwriteProperty('empty', function (_super) {
+    return function () {
+      var obj = flag(this, 'object');
+      if (obj instanceof jQuery) {
+        this.assert(
+          obj.is(':empty')
+          , 'expected #{this} to be empty'
+          , 'expected #{this} not to be empty');
+      } else {
+        _super.apply(this, arguments);
+      }
+    };
+  });
+
+  chai.Assertion.overwriteProperty('be', function (_super) {
+    return function () {
+      var be = function (selector) {
+        var obj = flag(this, 'object');
+        if (obj instanceof jQuery) {
+          this.assert(
+              obj.is(selector)
+            , 'expected #{this} to be #{exp}'
+            , 'expected #{this} not to be #{exp}'
+            , selector
+          );
+        } else {
+          _super.apply(this, arguments);
+        }
+      };
+      be.__proto__ = this;
+      return be;
+    }
+  });
+
+  chai.Assertion.overwriteMethod('match', function (_super) {
+    return function (selector) {
+      var obj = flag(this, 'object');
+      if (obj instanceof jQuery) {
+        this.assert(
+            obj.is(selector)
+          , 'expected #{this} to match #{exp}'
+          , 'expected #{this} not to match #{exp}'
+          , selector
+        );
+      } else {
+        _super.apply(this, arguments);
+      }
+    }
+  });
+
+  chai.Assertion.overwriteProperty('contain', function (_super) {
+    return function () {
+      _super.call(this);
+      var contain = function (text) {
+        var obj = flag(this, 'object');
+        if (obj instanceof jQuery) {
+          this.assert(
+              obj.is(':contains(\'' + text + '\')')
+            , 'expected #{this} to contain #{exp}'
+            , 'expected #{this} not to contain #{exp}'
+            , text
+          );
+        } else {
+          Function.prototype.apply.call(_super.call(this), this, arguments);
+        }
+      };
+      contain.__proto__ = this;
+      return contain;
+    }
+  });
+
+  chai.Assertion.overwriteProperty('have', function (_super) {
+    return function () {
+      var obj = flag(this, 'object');
+      if (obj instanceof jQuery) {
+        var have = function (selector) {
+          this.assert(
+              // Using find() rather than has() to work around a jQuery bug:
+              //   http://bugs.jquery.com/ticket/11706
+              obj.find(selector).length > 0
+            , 'expected #{this} to have #{exp}'
+            , 'expected #{this} not to have #{exp}'
+            , selector
+          );
+        };
+        have.__proto__ = this;
+        return have;
+      } else {
+        _super.call(this);
+      }
+    }
+  });
+}));