konacha-chai-matchers 0.2.0 → 0.3.0

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

@@ -0,0 +1,524 @@
+/*!
+ * chai-jq
+ * -------
+ * An alternate jQuery assertion library for Chai.
+ */
+(function () {
+  var root = this;
+
+  /*!
+   * Chai jQuery plugin implementation.
+   */
+  function chaiJq(chai, utils) {
+    "use strict";
+
+    // ------------------------------------------------------------------------
+    // Variables
+    // ------------------------------------------------------------------------
+    var flag = utils.flag,
+      toString = Object.prototype.toString;
+
+    // ------------------------------------------------------------------------
+    // Helpers
+    // ------------------------------------------------------------------------
+    /*!
+     * Give a more useful element name.
+     */
+    var _elName = function ($el) {
+      var name = "",
+        id = $el.attr("id"),
+        cls = $el.attr("class") || "";
+
+      // Try CSS selector id.
+      if (id) {
+        name += "#" + id;
+      }
+      if (cls) {
+        name += "." + cls.split(" ").join(".");
+      }
+      if (name) {
+        return "'" + name + "'";
+      }
+
+      // Give up.
+      return $el;
+    };
+
+    // ------------------------------------------------------------------------
+    // Type Inference
+    //
+    // (Inspired by Underscore)
+    // ------------------------------------------------------------------------
+    var _isRegExp = function (val) {
+      return toString.call(val) === "[object RegExp]";
+    };
+
+    // ------------------------------------------------------------------------
+    // Comparisons
+    // ------------------------------------------------------------------------
+    var _equals = function (exp, act) {
+      return exp === act;
+    };
+
+    var _contains = function (exp, act) {
+      return act.indexOf(exp) !== -1;
+    };
+
+    var _exists = function (exp, act) {
+      return act !== undefined;
+    };
+
+    var _regExpMatch = function (expRe, act) {
+      return expRe.exec(act);
+    };
+
+    // ------------------------------------------------------------------------
+    // Assertions (Internal)
+    // ------------------------------------------------------------------------
+    /*!
+     * Wrap assert function and add properties.
+     */
+    var _jqAssert = function (fn) {
+      return function (exp, msg) {
+        // Set properties.
+        this._$el = flag(this, "object");
+        this._name = _elName(this._$el);
+
+        // Flag message.
+        if (msg) {
+          flag(this, "message", msg);
+        }
+
+        // Invoke assertion function.
+        fn.apply(this, arguments);
+      };
+    };
+
+    /*!
+     * Base for the boolean is("selector") method call.
+     *
+     * @see http://api.jquery.com/is/]
+     *
+     * @param {String} selector jQuery selector to match against
+     */
+    var _isMethod = function (jqSelector) {
+      // Make selector human readable.
+      var selectorDesc = jqSelector.replace(/:/g, "");
+
+      // Return decorated assert.
+      return _jqAssert(function () {
+        this.assert(
+          this._$el.is(jqSelector),
+          "expected " + this._name + " to be " + selectorDesc,
+          "expected " + this._name + " to not be " + selectorDesc
+        );
+      });
+    };
+
+    /*!
+     * Abstract base for a "containable" method call.
+     *
+     * @param {String} jQuery           method name.
+     * @param {Object} opts             options
+     * @param {String} opts.hasArg      takes argument for method
+     * @param {String} opts.isProperty  switch assert context to property if no
+     *                                  expected val
+     * @param {String} opts.hasContains is "contains" applicable
+     * @param {String} opts.altGet      alternate function to get value if none
+     */
+    var _containMethod = function (jqMeth, opts) {
+      // Unpack options.
+      opts || (opts = {});
+      opts.hasArg       = !!opts.hasArg;
+      opts.isProperty   = !!opts.isProperty;
+      opts.hasContains  = !!opts.hasContains;
+      opts.defaultAct   = undefined;
+
+      // Return decorated assert.
+      return _jqAssert(function () {
+        // Arguments.
+        var exp = arguments[opts.hasArg ? 1 : 0],
+          arg = opts.hasArg ? arguments[0] : undefined,
+
+          // Switch context to property / check mere presence.
+          noExp = arguments.length === (opts.hasArg ? 1 : 0),
+          isProp = opts.isProperty && noExp,
+
+          // Method.
+          act = (opts.hasArg ? this._$el[jqMeth](arg) : this._$el[jqMeth]()),
+          meth = opts.hasArg ? jqMeth + "('" + arg + "')" : jqMeth,
+
+          // Assertion type.
+          contains = !isProp && opts.hasContains && flag(this, "contains"),
+          have = contains ? "contain" : "have",
+          comp = _equals;
+
+        // Set comparison.
+        if (isProp) {
+          comp = _exists;
+        } else if (contains) {
+          comp = _contains;
+        }
+
+        // Second chance getter.
+        if (opts.altGet && !act) {
+          act = opts.altGet(this._$el, arg);
+        }
+
+        // Default actual value on undefined.
+        if (typeof act === "undefined") {
+          act = opts.defaultAct;
+        }
+
+        // Same context assertion.
+        this.assert(
+          comp(exp, act),
+          "expected " + this._name + " to " + have + " " + meth +
+            (isProp ? "" : " #{exp} but found #{act}"),
+          "expected " + this._name + " not to " + have + " " + meth +
+            (isProp ? "" : " #{exp}"),
+          exp,
+          act
+        );
+
+        // Change context if property and not negated.
+        if (isProp && !flag(this, "negate")) {
+          flag(this, "object", act);
+        }
+      });
+    };
+
+    // ------------------------------------------------------------------------
+    // API
+    // ------------------------------------------------------------------------
+
+    /**
+     * Asserts that the element is visible.
+     *
+     * *Node.js/JsDom Note*: JsDom does not currently infer zero-sized or
+     * hidden parent elements as hidden / visible appropriately.
+     *
+     * ```js
+     * expect($("<div>&nbsp;</div>"))
+     *   .to.be.$visible;
+     * ```
+     *
+     * @see http://api.jquery.com/visible-selector/
+     *
+     * @api public
+     */
+    var $visible = _isMethod(":visible");
+
+    chai.Assertion.addProperty("$visible", $visible);
+
+    /**
+     * Asserts that the element is hidden.
+     *
+     * *Node.js/JsDom Note*: JsDom does not currently infer zero-sized or
+     * hidden parent elements as hidden / visible appropriately.
+     *
+     * ```js
+     * expect($("<div style=\"display: none\" />"))
+     *   .to.be.$hidden;
+     * ```
+     *
+     * @see http://api.jquery.com/hidden-selector/
+     *
+     * @api public
+     */
+    var $hidden = _isMethod(":hidden");
+
+    chai.Assertion.addProperty("$hidden", $hidden);
+
+    /**
+     * Asserts that the element value matches a string or regular expression.
+     *
+     * ```js
+     * expect($("<input value='foo' />"))
+     *   .to.have.$val("foo").and
+     *   .to.have.$val(/^foo/);
+     * ```
+     *
+     * @see http://api.jquery.com/val/
+     *
+     * @param {String|RegExp} expected  value
+     * @param {String}        message   failure message (_optional_)
+     * @api public
+     */
+    var $val = _jqAssert(function (exp) {
+      var act = this._$el.val(),
+        comp = _isRegExp(exp) ? _regExpMatch : _equals;
+
+      this.assert(
+        comp(exp, act),
+        "expected " + this._name + " to have val #{exp} but found #{act}",
+        "expected " + this._name + " not to have val #{exp}",
+        exp,
+        typeof act === "undefined" ? "undefined" : act
+      );
+    });
+
+    chai.Assertion.addMethod("$val", $val);
+
+    /**
+     * Asserts that the element has a class match.
+     *
+     * ```js
+     * expect($("<div class='foo bar' />"))
+     *   .to.have.$class("foo").and
+     *   .to.have.$class("bar");
+     * ```
+     *
+     * @see http://api.jquery.com/hasClass/
+     *
+     * @param {String} expected class name
+     * @param {String} message  failure message (_optional_)
+     * @api public
+     */
+    var $class = _jqAssert(function (exp) {
+      var act = this._$el.attr("class") || "";
+
+      this.assert(
+        this._$el.hasClass(exp),
+        "expected " + this._name + " to have class #{exp} but found #{act}",
+        "expected " + this._name + " not to have class #{exp}",
+        exp,
+        act
+      );
+    });
+
+    chai.Assertion.addMethod("$class", $class);
+
+    /**
+     * Asserts that the target has exactly the given named attribute, or
+     * asserts the target contains a subset of the attribute when using the
+     * `include` or `contain` modifiers.
+     *
+     * ```js
+     * expect($("<div id=\"hi\" foo=\"bar time\" />"))
+     *   .to.have.$attr("id", "hi").and
+     *   .to.contain.$attr("foo", "bar");
+     * ```
+     *
+     * Changes context to attribute string *value* when no expected value is
+     * provided:
+     *
+     * ```js
+     * expect($("<div id=\"hi\" foo=\"bar time\" />"))
+     *   .to.have.$attr("foo").and
+     *     .to.equal("bar time").and
+     *     .to.match(/^b/);
+     * ```
+     *
+     * @see http://api.jquery.com/attr/
+     *
+     * @param {String} name     attribute name
+     * @param {String} expected attribute content (_optional_)
+     * @param {String} message  failure message (_optional_)
+     * @returns current object or attribute string value
+     * @api public
+     */
+    var $attr = _containMethod("attr", {
+      hasArg: true,
+      hasContains: true,
+      isProperty: true
+    });
+
+    chai.Assertion.addMethod("$attr", $attr);
+
+    /**
+     * Asserts that the target has exactly the given named 
+     * data-attribute, or asserts the target contains a subset 
+     * of the data-attribute when using the
+     * `include` or `contain` modifiers.
+     *
+     * ```js
+     * expect($("<div data-id=\"hi\" data-foo=\"bar time\" />"))
+     *   .to.have.$data("id", "hi").and
+     *   .to.contain.$data("foo", "bar");
+     * ```
+     *
+     * Changes context to data-attribute string *value* when no 
+     * expected value is provided:
+     *
+     * ```js
+     * expect($("<div data-id=\"hi\" data-foo=\"bar time\" />"))
+     *   .to.have.$data("foo").and
+     *     .to.equal("bar time").and
+     *     .to.match(/^b/);
+     * ```
+     *
+     * @see http://api.jquery.com/data/
+     *
+     * @param {String} name     data-attribute name
+     * @param {String} expected data-attribute content (_optional_)
+     * @param {String} message  failure message (_optional_)
+     * @returns current object or attribute string value
+     * @api public
+     */
+    var $data = _containMethod("data", {
+      hasArg: true,
+      hasContains: true,
+      isProperty: true
+    });
+
+    chai.Assertion.addMethod("$data", $data);
+
+    /**
+     * Asserts that the target has exactly the given named property.
+     *
+     * ```js
+     * expect($("<input type=\"checkbox\" checked=\"checked\" />"))
+     *   .to.have.$prop("checked", true).and
+     *   .to.have.$prop("type", "checkbox");
+     * ```
+     *
+     * Changes context to property string *value* when no expected value is
+     * provided:
+     *
+     * ```js
+     * expect($("<input type=\"checkbox\" checked=\"checked\" />"))
+     *   .to.have.$prop("type").and
+     *     .to.equal("checkbox").and
+     *     .to.match(/^c.*x$/);
+     * ```
+     *
+     * @see http://api.jquery.com/prop/
+     *
+     * @param {String} name     property name
+     * @param {Object} expected property value (_optional_)
+     * @param {String} message  failure message (_optional_)
+     * @returns current object or property string value
+     * @api public
+     */
+    var $prop = _containMethod("prop", {
+      hasArg: true,
+      isProperty: true
+    });
+
+    chai.Assertion.addMethod("$prop", $prop);
+
+    /**
+     * Asserts that the target has exactly the given HTML, or
+     * asserts the target contains a subset of the HTML when using the
+     * `include` or `contain` modifiers.
+     *
+     * ```js
+     * expect($("<div><span>foo</span></div>"))
+     *   .to.have.$html("<span>foo</span>").and
+     *   .to.contain.$html("foo");
+     * ```
+     *
+     * @see http://api.jquery.com/html/
+     *
+     * @param {String} expected HTML content
+     * @param {String} message  failure message (_optional_)
+     * @api public
+     */
+    var $html = _containMethod("html", {
+      hasContains: true
+    });
+
+    chai.Assertion.addMethod("$html", $html);
+
+    /**
+     * Asserts that the target has exactly the given text, or
+     * asserts the target contains a subset of the text when using the
+     * `include` or `contain` modifiers.
+     *
+     * ```js
+     * expect($("<div><span>foo</span> bar</div>"))
+     *   .to.have.$text("foo bar").and
+     *   .to.contain.$text("foo");
+     * ```
+     *
+     * @see http://api.jquery.com/text/
+     *
+     * @name $text
+     * @param {String} expected text content
+     * @param {String} message  failure message (_optional_)
+     * @api public
+     */
+    var $text = _containMethod("text", {
+      hasContains: true
+    });
+
+    chai.Assertion.addMethod("$text", $text);
+
+    /**
+     * Asserts that the target has exactly the given CSS property, or
+     * asserts the target contains a subset of the CSS when using the
+     * `include` or `contain` modifiers.
+     *
+     * *Node.js/JsDom Note*: Computed CSS properties are not correctly
+     * inferred as of JsDom v0.8.8. Explicit ones should get matched exactly.
+     *
+     * *Browser Note*: Explicit CSS properties are sometimes not matched
+     * (in contrast to Node.js), so the plugin performs an extra check against
+     * explicit `style` properties for a match. May still have other wonky
+     * corner cases.
+     *
+     * *PhantomJS Note*: PhantomJS also is fairly wonky and unpredictable with
+     * respect to CSS / styles, especially those that come from CSS classes
+     * and not explicity `style` attributes.
+     *
+     * ```js
+     * expect($("<div style=\"width: 50px; border: 1px dotted black;\" />"))
+     *   .to.have.$css("width", "50px").and
+     *   .to.have.$css("border-top-style", "dotted");
+     * ```
+     *
+     * @see http://api.jquery.com/css/
+     *
+     * @name $css
+     * @param {String} expected CSS property content
+     * @param {String} message  failure message (_optional_)
+     * @api public
+     */
+    var $css = _containMethod("css", {
+      hasArg: true,
+      hasContains: true,
+
+      // Alternate Getter: If no match, go for explicit property.
+      altGet: function ($el, prop) { return $el.prop("style")[prop]; }
+    });
+
+    chai.Assertion.addMethod("$css", $css);
+  }
+
+  /*!
+   * Wrap AMD, etc. using boilerplate.
+   */
+  function wrap(plugin) {
+    "use strict";
+    /* global module:false, define:false */
+
+    if (typeof require === "function" &&
+        typeof exports === "object" &&
+        typeof module  === "object") {
+      // NodeJS
+      module.exports = plugin;
+
+    } else if (typeof define === "function" && define.amd) {
+      // AMD: Assumes importing `chai` and `jquery`. Returns a function to
+      //      inject with `chai.use()`.
+      //
+      // See: https://github.com/chaijs/chai-jquery/issues/27
+      define(["jquery"], function ($) {
+        return function (chai, utils) {
+          return plugin(chai, utils, $);
+        };
+      });
+
+    } else {
+      // Other environment (usually <script> tag): plug in to global chai
+      // instance directly.
+      root.chai.use(function (chai, utils) {
+        return plugin(chai, utils, root.jQuery);
+      });
+    }
+  }
+
+  // Hook it all together.
+  wrap(chaiJq);
+}());