\n\n});\n\ntest('test config item when to be set on all fields', function () {\n var form = fixture('');\n var test1ran = false;\n\n form.isHappy({\n fields: {\n '#textInput1': {\n test: function () {\n test1ran = true;\n return true;\n }\n }\n },\n when: 'keyup',\n testMode: true\n });\n\n $('#textInput1').val('asdf').trigger('blur');\n equal(test1ran, false);\n $('#textInput1').val('asdf').trigger('keyup');\n equal(test1ran, true);\n});\n\ntest('test config item when to be set on a unique field', function () {\n var form = fixture('');\n var test1ran = false;\n var test2ran = false;\n\n form.isHappy({\n fields: {\n '#textInput1': {\n test: function () {\n test1ran = true;\n return true;\n }\n },\n '#textInput2': {\n test: function () {\n test2ran = true;\n return true;\n },\n when: 'keyup'\n }\n },\n testMode: true\n });\n\n $('#textInput1').val('asdf').trigger('keyup');\n equal(test1ran, false);\n $('#textInput1').val('asdf').trigger('blur');\n equal(test1ran, true);\n $('#textInput2').val('asdf').trigger('keyup');\n equal(test2ran, true);\n\n});\n\ntest('test custom classes', function () {\n var form = fixture('');\n form.isHappy({\n fields: {\n '#textInput1': {\n required: true\n },\n },\n classes: {\n field: 'error',\n message: 'errorMsg'\n },\n testMode: true\n });\n\n form.submit();\n equal($('#textInput1').attr('class'), 'error');\n equal($('#textInput1_unhappy').attr('class'), 'errorMsg');\n\n $('#textInput1').val('asdf');\n form.submit();\n equal($('#textInput1').attr('class'), '');\n});\n\ntest('checkbox values aren\\'t clobbered', function () {\n var form = fixture('');\n\n form.isHappy({\n fields: {\n '.answer': {\n required: true\n }\n },\n testMode: true\n });\n\n form.submit();\n equal($('#valueA').attr('value'), 'a');\n equal($('#valueB').attr('value'), 'b');\n});\n\ntest('check name attribute selector', function () {\n var form = fixture('');\n\n form.isHappy({\n fields: {\n '[name=\"textInput1\"]': {\n required: true,\n message: 'Please enter an email'\n }\n },\n testMode: true\n });\n\n form.trigger('submit');\n equal($('.unhappy').length, 1);\n equal($('.unhappyMessage').length, 1);\n\n $('[name=\"textInput1\"]').val('test');\n form.trigger('submit');\n equal($('.unhappy').length, 0);\n equal($('.unhappyMessage').length, 0);\n});\n\ntest('error message persists until valid', function() {\n var form = fixture('');\n\n form.isHappy({\n fields: {\n '#textInput1': {\n required: true,\n message: 'Please enter an email'\n }\n },\n testMode: true\n });\n\n form.trigger('submit');\n equal($('#textInput1_unhappy').text(), 'Please enter an email', 'Error message present after submit.');\n $('#textInput1').trigger('blur');\n equal($('#textInput1_unhappy').text(), 'Please enter an email', 'Error message persists after blur.');\n $('#textInput1').val('name@example.com');\n form.trigger('submit');\n equal($('#textInput1_unhappy').length, 0, 'Error message removed with valid value.');\n});\n\ntest('custom error messages', function() {\n var form = fixture('');\n\n form.isHappy({\n fields: {\n '#textInput1': {\n required: true,\n test: function(value) {\n\n var birthday = new Date(value);\n var birthdayInt = birthday.getTime();\n\n if (isNaN(birthdayInt)) {\n return false;\n }\n if(birthdayInt > new Date()) {\n return new Error('Your birthday must have already happened.');\n }\n if (birthday.getDay() === 3) {\n return new Error('Your birthday cannot have happened on a Wednesday.');\n }\n return true;\n },\n message: 'Please provide a valid birth date.'\n }\n },\n testMode: true\n });\n\n form.trigger('submit');\n equal($('#textInput1_unhappy').text(), 'Please provide a valid birth date.', 'Default error message is shown.');\n\n // tomorrow\n var dateVal = new Date(new Date().getTime() + (1000 * 60 * 60 * 24)).toString();\n $('#textInput1').val(dateVal);\n form.trigger('submit');\n equal($('#textInput1_unhappy').text(), 'Your birthday must have already happened.', 'Future dates are invalid.');\n\n $('#textInput1').val('foo');\n form.trigger('submit');\n equal($('#textInput1_unhappy').text(), 'Please provide a valid birth date.', 'Default error message is shown for poorly formatted dates.');\n\n $('#textInput1').val('11/04/2015');\n form.trigger('submit');\n equal($('#textInput1_unhappy').text(), 'Your birthday cannot have happened on a Wednesday.', 'Testing for another custom message.');\n\n $('#textInput1').val('01/01/1989');\n form.trigger('submit');\n equal($('#textInput1_unhappy').length, 0, 'Error message removed with valid value.');\n});\n\ntest('test support for multiple tests', function() {\n var form = fixture('');\n\n function minLength(val, arg) {\n return val.length < arg[0] ? new Error('Your name must be longer.') : true;\n }\n\n function maxLength(val, arg) {\n return val.length > arg[1] ? new Error('Your name must be shorter.') : true;\n }\n\n form.isHappy({\n fields: {\n '#textInput1': {\n required: true,\n message: 'Might we inquire your name',\n test: [minLength, maxLength],\n arg: [3, 32]\n }\n },\n testMode: true\n });\n\n $('#textInput1').val('xx');\n form.trigger('submit');\n equal($('#textInput1_unhappy').text(), 'Your name must be longer.', 'Stop after first test fails.');\n\n $('#textInput1').val((new Array(42)).join('x'));\n form.trigger('submit');\n equal($('#textInput1_unhappy').text(), 'Your name must be shorter.', 'Second test fails.');\n\n $('#textInput1').val('John Smith');\n form.trigger('submit');\n equal($('#textInput1_unhappy').length, 0, 'All tests pass.');\n});\n" }, { "path": "test/underscore.js", "content": "// Underscore.js 1.1.4\n// (c) 2011 Jeremy Ashkenas, DocumentCloud Inc.\n// Underscore is freely distributable under the MIT license.\n// Portions of Underscore are inspired or borrowed from Prototype,\n// Oliver Steele's Functional, and John Resig's Micro-Templating.\n// For all details and documentation:\n// http://documentcloud.github.com/underscore\n\n(function() {\n\n // Baseline setup\n // --------------\n\n // Establish the root object, `window` in the browser, or `global` on the server.\n var root = this;\n\n // Save the previous value of the `_` variable.\n var previousUnderscore = root._;\n\n // Establish the object that gets returned to break out of a loop iteration.\n var breaker = {};\n\n // Save bytes in the minified (but not gzipped) version:\n var ArrayProto = Array.prototype, ObjProto = Object.prototype;\n\n // Create quick reference variables for speed access to core prototypes.\n var slice = ArrayProto.slice,\n unshift = ArrayProto.unshift,\n toString = ObjProto.toString,\n hasOwnProperty = ObjProto.hasOwnProperty;\n\n // All **ECMAScript 5** native function implementations that we hope to use\n // are declared here.\n var\n nativeForEach = ArrayProto.forEach,\n nativeMap = ArrayProto.map,\n nativeReduce = ArrayProto.reduce,\n nativeReduceRight = ArrayProto.reduceRight,\n nativeFilter = ArrayProto.filter,\n nativeEvery = ArrayProto.every,\n nativeSome = ArrayProto.some,\n nativeIndexOf = ArrayProto.indexOf,\n nativeLastIndexOf = ArrayProto.lastIndexOf,\n nativeIsArray = Array.isArray,\n nativeKeys = Object.keys;\n\n // Create a safe reference to the Underscore object for use below.\n var _ = function(obj) { return new wrapper(obj); };\n\n // Export the Underscore object for **CommonJS**, with backwards-compatibility\n // for the old `require()` API. If we're not in CommonJS, add `_` to the\n // global object.\n if (typeof module !== 'undefined' && module.exports) {\n module.exports = _;\n _._ = _;\n } else {\n root._ = _;\n }\n\n // Current version.\n _.VERSION = '1.1.4';\n\n // Collection Functions\n // --------------------\n\n // The cornerstone, an `each` implementation, aka `forEach`.\n // Handles objects implementing `forEach`, arrays, and raw objects.\n // Delegates to **ECMAScript 5**'s native `forEach` if available.\n var each = _.each = _.forEach = function(obj, iterator, context) {\n var value;\n if (obj == null) return;\n if (nativeForEach && obj.forEach === nativeForEach) {\n obj.forEach(iterator, context);\n } else if (_.isNumber(obj.length)) {\n for (var i = 0, l = obj.length; i < l; i++) {\n if (iterator.call(context, obj[i], i, obj) === breaker) return;\n }\n } else {\n for (var key in obj) {\n if (hasOwnProperty.call(obj, key)) {\n if (iterator.call(context, obj[key], key, obj) === breaker) return;\n }\n }\n }\n };\n\n // Return the results of applying the iterator to each element.\n // Delegates to **ECMAScript 5**'s native `map` if available.\n _.map = function(obj, iterator, context) {\n var results = [];\n if (obj == null) return results;\n if (nativeMap && obj.map === nativeMap) return obj.map(iterator, context);\n each(obj, function(value, index, list) {\n results[results.length] = iterator.call(context, value, index, list);\n });\n return results;\n };\n\n // **Reduce** builds up a single result from a list of values, aka `inject`,\n // or `foldl`. Delegates to **ECMAScript 5**'s native `reduce` if available.\n _.reduce = _.foldl = _.inject = function(obj, iterator, memo, context) {\n var initial = memo !== void 0;\n if (obj == null) obj = [];\n if (nativeReduce && obj.reduce === nativeReduce) {\n if (context) iterator = _.bind(iterator, context);\n return initial ? obj.reduce(iterator, memo) : obj.reduce(iterator);\n }\n each(obj, function(value, index, list) {\n if (!initial && index === 0) {\n memo = value;\n initial = true;\n } else {\n memo = iterator.call(context, memo, value, index, list);\n }\n });\n if (!initial) throw new TypeError(\"Reduce of empty array with no initial value\");\n return memo;\n };\n\n // The right-associative version of reduce, also known as `foldr`.\n // Delegates to **ECMAScript 5**'s native `reduceRight` if available.\n _.reduceRight = _.foldr = function(obj, iterator, memo, context) {\n if (obj == null) obj = [];\n if (nativeReduceRight && obj.reduceRight === nativeReduceRight) {\n if (context) iterator = _.bind(iterator, context);\n return memo !== void 0 ? obj.reduceRight(iterator, memo) : obj.reduceRight(iterator);\n }\n var reversed = (_.isArray(obj) ? obj.slice() : _.toArray(obj)).reverse();\n return _.reduce(reversed, iterator, memo, context);\n };\n\n // Return the first value which passes a truth test. Aliased as `detect`.\n _.find = _.detect = function(obj, iterator, context) {\n var result;\n any(obj, function(value, index, list) {\n if (iterator.call(context, value, index, list)) {\n result = value;\n return true;\n }\n });\n return result;\n };\n\n // Return all the elements that pass a truth test.\n // Delegates to **ECMAScript 5**'s native `filter` if available.\n // Aliased as `select`.\n _.filter = _.select = function(obj, iterator, context) {\n var results = [];\n if (obj == null) return results;\n if (nativeFilter && obj.filter === nativeFilter) return obj.filter(iterator, context);\n each(obj, function(value, index, list) {\n if (iterator.call(context, value, index, list)) results[results.length] = value;\n });\n return results;\n };\n\n // Return all the elements for which a truth test fails.\n _.reject = function(obj, iterator, context) {\n var results = [];\n if (obj == null) return results;\n each(obj, function(value, index, list) {\n if (!iterator.call(context, value, index, list)) results[results.length] = value;\n });\n return results;\n };\n\n // Determine whether all of the elements match a truth test.\n // Delegates to **ECMAScript 5**'s native `every` if available.\n // Aliased as `all`.\n _.every = _.all = function(obj, iterator, context) {\n iterator = iterator || _.identity;\n var result = true;\n if (obj == null) return result;\n if (nativeEvery && obj.every === nativeEvery) return obj.every(iterator, context);\n each(obj, function(value, index, list) {\n if (!(result = result && iterator.call(context, value, index, list))) return breaker;\n });\n return result;\n };\n\n // Determine if at least one element in the object matches a truth test.\n // Delegates to **ECMAScript 5**'s native `some` if available.\n // Aliased as `any`.\n var any = _.some = _.any = function(obj, iterator, context) {\n iterator = iterator || _.identity;\n var result = false;\n if (obj == null) return result;\n if (nativeSome && obj.some === nativeSome) return obj.some(iterator, context);\n each(obj, function(value, index, list) {\n if (result = iterator.call(context, value, index, list)) return breaker;\n });\n return result;\n };\n\n // Determine if a given value is included in the array or object using `===`.\n // Aliased as `contains`.\n _.include = _.contains = function(obj, target) {\n var found = false;\n if (obj == null) return found;\n if (nativeIndexOf && obj.indexOf === nativeIndexOf) return obj.indexOf(target) != -1;\n any(obj, function(value) {\n if (found = value === target) return true;\n });\n return found;\n };\n\n // Invoke a method (with arguments) on every item in a collection.\n _.invoke = function(obj, method) {\n var args = slice.call(arguments, 2);\n return _.map(obj, function(value) {\n return (method ? value[method] : value).apply(value, args);\n });\n };\n\n // Convenience version of a common use case of `map`: fetching a property.\n _.pluck = function(obj, key) {\n return _.map(obj, function(value){ return value[key]; });\n };\n\n // Return the maximum element or (element-based computation).\n _.max = function(obj, iterator, context) {\n if (!iterator && _.isArray(obj)) return Math.max.apply(Math, obj);\n var result = {computed : -Infinity};\n each(obj, function(value, index, list) {\n var computed = iterator ? iterator.call(context, value, index, list) : value;\n computed >= result.computed && (result = {value : value, computed : computed});\n });\n return result.value;\n };\n\n // Return the minimum element (or element-based computation).\n _.min = function(obj, iterator, context) {\n if (!iterator && _.isArray(obj)) return Math.min.apply(Math, obj);\n var result = {computed : Infinity};\n each(obj, function(value, index, list) {\n var computed = iterator ? iterator.call(context, value, index, list) : value;\n computed < result.computed && (result = {value : value, computed : computed});\n });\n return result.value;\n };\n\n // Sort the object's values by a criterion produced by an iterator.\n _.sortBy = function(obj, iterator, context) {\n return _.pluck(_.map(obj, function(value, index, list) {\n return {\n value : value,\n criteria : iterator.call(context, value, index, list)\n };\n }).sort(function(left, right) {\n var a = left.criteria, b = right.criteria;\n return a < b ? -1 : a > b ? 1 : 0;\n }), 'value');\n };\n\n // Use a comparator function to figure out at what index an object should\n // be inserted so as to maintain order. Uses binary search.\n _.sortedIndex = function(array, obj, iterator) {\n iterator = iterator || _.identity;\n var low = 0, high = array.length;\n while (low < high) {\n var mid = (low + high) >> 1;\n iterator(array[mid]) < iterator(obj) ? low = mid + 1 : high = mid;\n }\n return low;\n };\n\n // Safely convert anything iterable into a real, live array.\n _.toArray = function(iterable) {\n if (!iterable) return [];\n if (iterable.toArray) return iterable.toArray();\n if (_.isArray(iterable)) return iterable;\n if (_.isArguments(iterable)) return slice.call(iterable);\n return _.values(iterable);\n };\n\n // Return the number of elements in an object.\n _.size = function(obj) {\n return _.toArray(obj).length;\n };\n\n // Array Functions\n // ---------------\n\n // Get the first element of an array. Passing **n** will return the first N\n // values in the array. Aliased as `head`. The **guard** check allows it to work\n // with `_.map`.\n _.first = _.head = function(array, n, guard) {\n return n && !guard ? slice.call(array, 0, n) : array[0];\n };\n\n // Returns everything but the first entry of the array. Aliased as `tail`.\n // Especially useful on the arguments object. Passing an **index** will return\n // the rest of the values in the array from that index onward. The **guard**\n // check allows it to work with `_.map`.\n _.rest = _.tail = function(array, index, guard) {\n return slice.call(array, _.isUndefined(index) || guard ? 1 : index);\n };\n\n // Get the last element of an array.\n _.last = function(array) {\n return array[array.length - 1];\n };\n\n // Trim out all falsy values from an array.\n _.compact = function(array) {\n return _.filter(array, function(value){ return !!value; });\n };\n\n // Return a completely flattened version of an array.\n _.flatten = function(array) {\n return _.reduce(array, function(memo, value) {\n if (_.isArray(value)) return memo.concat(_.flatten(value));\n memo[memo.length] = value;\n return memo;\n }, []);\n };\n\n // Return a version of the array that does not contain the specified value(s).\n _.without = function(array) {\n var values = slice.call(arguments, 1);\n return _.filter(array, function(value){ return !_.include(values, value); });\n };\n\n // Produce a duplicate-free version of the array. If the array has already\n // been sorted, you have the option of using a faster algorithm.\n // Aliased as `unique`.\n _.uniq = _.unique = function(array, isSorted) {\n return _.reduce(array, function(memo, el, i) {\n if (0 == i || (isSorted === true ? _.last(memo) != el : !_.include(memo, el))) memo[memo.length] = el;\n return memo;\n }, []);\n };\n\n // Produce an array that contains every item shared between all the\n // passed-in arrays.\n _.intersect = function(array) {\n var rest = slice.call(arguments, 1);\n return _.filter(_.uniq(array), function(item) {\n return _.every(rest, function(other) {\n return _.indexOf(other, item) >= 0;\n });\n });\n };\n\n // Zip together multiple lists into a single array -- elements that share\n // an index go together.\n _.zip = function() {\n var args = slice.call(arguments);\n var length = _.max(_.pluck(args, 'length'));\n var results = new Array(length);\n for (var i = 0; i < length; i++) results[i] = _.pluck(args, \"\" + i);\n return results;\n };\n\n // If the browser doesn't supply us with indexOf (I'm looking at you, **MSIE**),\n // we need this function. Return the position of the first occurrence of an\n // item in an array, or -1 if the item is not included in the array.\n // Delegates to **ECMAScript 5**'s native `indexOf` if available.\n // If the array is large and already in sort order, pass `true`\n // for **isSorted** to use binary search.\n _.indexOf = function(array, item, isSorted) {\n if (array == null) return -1;\n if (isSorted) {\n var i = _.sortedIndex(array, item);\n return array[i] === item ? i : -1;\n }\n if (nativeIndexOf && array.indexOf === nativeIndexOf) return array.indexOf(item);\n for (var i = 0, l = array.length; i < l; i++) if (array[i] === item) return i;\n return -1;\n };\n\n\n // Delegates to **ECMAScript 5**'s native `lastIndexOf` if available.\n _.lastIndexOf = function(array, item) {\n if (array == null) return -1;\n if (nativeLastIndexOf && array.lastIndexOf === nativeLastIndexOf) return array.lastIndexOf(item);\n var i = array.length;\n while (i--) if (array[i] === item) return i;\n return -1;\n };\n\n // Generate an integer Array containing an arithmetic progression. A port of\n // the native Python `range()` function. See\n // [the Python documentation](http://docs.python.org/library/functions.html#range).\n _.range = function(start, stop, step) {\n var args = slice.call(arguments),\n solo = args.length <= 1,\n start = solo ? 0 : args[0],\n stop = solo ? args[0] : args[1],\n step = args[2] || 1,\n len = Math.max(Math.ceil((stop - start) / step), 0),\n idx = 0,\n range = new Array(len);\n while (idx < len) {\n range[idx++] = start;\n start += step;\n }\n return range;\n };\n\n // Function (ahem) Functions\n // ------------------\n\n // Create a function bound to a given object (assigning `this`, and arguments,\n // optionally). Binding with arguments is also known as `curry`.\n _.bind = function(func, obj) {\n var args = slice.call(arguments, 2);\n return function() {\n return func.apply(obj || {}, args.concat(slice.call(arguments)));\n };\n };\n\n // Bind all of an object's methods to that object. Useful for ensuring that\n // all callbacks defined on an object belong to it.\n _.bindAll = function(obj) {\n var funcs = slice.call(arguments, 1);\n if (funcs.length == 0) funcs = _.functions(obj);\n each(funcs, function(f) { obj[f] = _.bind(obj[f], obj); });\n return obj;\n };\n\n // Memoize an expensive function by storing its results.\n _.memoize = function(func, hasher) {\n var memo = {};\n hasher = hasher || _.identity;\n return function() {\n var key = hasher.apply(this, arguments);\n return key in memo ? memo[key] : (memo[key] = func.apply(this, arguments));\n };\n };\n\n // Delays a function for the given number of milliseconds, and then calls\n // it with the arguments supplied.\n _.delay = function(func, wait) {\n var args = slice.call(arguments, 2);\n return setTimeout(function(){ return func.apply(func, args); }, wait);\n };\n\n // Defers a function, scheduling it to run after the current call stack has\n // cleared.\n _.defer = function(func) {\n return _.delay.apply(_, [func, 1].concat(slice.call(arguments, 1)));\n };\n\n // Internal function used to implement `_.throttle` and `_.debounce`.\n var limit = function(func, wait, debounce) {\n var timeout;\n return function() {\n var context = this, args = arguments;\n var throttler = function() {\n timeout = null;\n func.apply(context, args);\n };\n if (debounce) clearTimeout(timeout);\n if (debounce || !timeout) timeout = setTimeout(throttler, wait);\n };\n };\n\n // Returns a function, that, when invoked, will only be triggered at most once\n // during a given window of time.\n _.throttle = function(func, wait) {\n return limit(func, wait, false);\n };\n\n // Returns a function, that, as long as it continues to be invoked, will not\n // be triggered. The function will be called after it stops being called for\n // N milliseconds.\n _.debounce = function(func, wait) {\n return limit(func, wait, true);\n };\n\n // Returns the first function passed as an argument to the second,\n // allowing you to adjust arguments, run code before and after, and\n // conditionally execute the original function.\n _.wrap = function(func, wrapper) {\n return function() {\n var args = [func].concat(slice.call(arguments));\n return wrapper.apply(this, args);\n };\n };\n\n // Returns a function that is the composition of a list of functions, each\n // consuming the return value of the function that follows.\n _.compose = function() {\n var funcs = slice.call(arguments);\n return function() {\n var args = slice.call(arguments);\n for (var i=funcs.length-1; i >= 0; i--) {\n args = [funcs[i].apply(this, args)];\n }\n return args[0];\n };\n };\n\n // Object Functions\n // ----------------\n\n // Retrieve the names of an object's properties.\n // Delegates to **ECMAScript 5**'s native `Object.keys`\n _.keys = nativeKeys || function(obj) {\n if (_.isArray(obj)) return _.range(0, obj.length);\n var keys = [];\n for (var key in obj) if (hasOwnProperty.call(obj, key)) keys[keys.length] = key;\n return keys;\n };\n\n // Retrieve the values of an object's properties.\n _.values = function(obj) {\n return _.map(obj, _.identity);\n };\n\n // Return a sorted list of the function names available on the object.\n // Aliased as `methods`\n _.functions = _.methods = function(obj) {\n return _.filter(_.keys(obj), function(key){ return _.isFunction(obj[key]); }).sort();\n };\n\n // Extend a given object with all the properties in passed-in object(s).\n _.extend = function(obj) {\n each(slice.call(arguments, 1), function(source) {\n for (var prop in source) obj[prop] = source[prop];\n });\n return obj;\n };\n\n // Create a (shallow-cloned) duplicate of an object.\n _.clone = function(obj) {\n return _.isArray(obj) ? obj.slice() : _.extend({}, obj);\n };\n\n // Invokes interceptor with the obj, and then returns obj.\n // The primary purpose of this method is to \"tap into\" a method chain, in\n // order to perform operations on intermediate results within the chain.\n _.tap = function(obj, interceptor) {\n interceptor(obj);\n return obj;\n };\n\n // Perform a deep comparison to check if two objects are equal.\n _.isEqual = function(a, b) {\n // Check object identity.\n if (a === b) return true;\n // Different types?\n var atype = typeof(a), btype = typeof(b);\n if (atype != btype) return false;\n // Basic equality test (watch out for coercions).\n if (a == b) return true;\n // One is falsy and the other truthy.\n if ((!a && b) || (a && !b)) return false;\n // Unwrap any wrapped objects.\n if (a._chain) a = a._wrapped;\n if (b._chain) b = b._wrapped;\n // One of them implements an isEqual()?\n if (a.isEqual) return a.isEqual(b);\n // Check dates' integer values.\n if (_.isDate(a) && _.isDate(b)) return a.getTime() === b.getTime();\n // Both are NaN?\n if (_.isNaN(a) && _.isNaN(b)) return false;\n // Compare regular expressions.\n if (_.isRegExp(a) && _.isRegExp(b))\n return a.source === b.source &&\n a.global === b.global &&\n a.ignoreCase === b.ignoreCase &&\n a.multiline === b.multiline;\n // If a is not an object by this point, we can't handle it.\n if (atype !== 'object') return false;\n // Check for different array lengths before comparing contents.\n if (a.length && (a.length !== b.length)) return false;\n // Nothing else worked, deep compare the contents.\n var aKeys = _.keys(a), bKeys = _.keys(b);\n // Different object sizes?\n if (aKeys.length != bKeys.length) return false;\n // Recursive comparison of contents.\n for (var key in a) if (!(key in b) || !_.isEqual(a[key], b[key])) return false;\n return true;\n };\n\n // Is a given array or object empty?\n _.isEmpty = function(obj) {\n if (_.isArray(obj) || _.isString(obj)) return obj.length === 0;\n for (var key in obj) if (hasOwnProperty.call(obj, key)) return false;\n return true;\n };\n\n // Is a given value a DOM element?\n _.isElement = function(obj) {\n return !!(obj && obj.nodeType == 1);\n };\n\n // Is a given value an array?\n // Delegates to ECMA5's native Array.isArray\n _.isArray = nativeIsArray || function(obj) {\n return toString.call(obj) === '[object Array]';\n };\n\n // Is a given variable an arguments object?\n _.isArguments = function(obj) {\n return !!(obj && hasOwnProperty.call(obj, 'callee'));\n };\n\n // Is a given value a function?\n _.isFunction = function(obj) {\n return !!(obj && obj.constructor && obj.call && obj.apply);\n };\n\n // Is a given value a string?\n _.isString = function(obj) {\n return !!(obj === '' || (obj && obj.charCodeAt && obj.substr));\n };\n\n // Is a given value a number?\n _.isNumber = function(obj) {\n return !!(obj === 0 || (obj && obj.toExponential && obj.toFixed));\n };\n\n // Is the given value `NaN`? `NaN` happens to be the only value in JavaScript\n // that does not equal itself.\n _.isNaN = function(obj) {\n return obj !== obj;\n };\n\n // Is a given value a boolean?\n _.isBoolean = function(obj) {\n return obj === true || obj === false;\n };\n\n // Is a given value a date?\n _.isDate = function(obj) {\n return !!(obj && obj.getTimezoneOffset && obj.setUTCFullYear);\n };\n\n // Is the given value a regular expression?\n _.isRegExp = function(obj) {\n return !!(obj && obj.test && obj.exec && (obj.ignoreCase || obj.ignoreCase === false));\n };\n\n // Is a given value equal to null?\n _.isNull = function(obj) {\n return obj === null;\n };\n\n // Is a given variable undefined?\n _.isUndefined = function(obj) {\n return obj === void 0;\n };\n\n // Utility Functions\n // -----------------\n\n // Run Underscore.js in *noConflict* mode, returning the `_` variable to its\n // previous owner. Returns a reference to the Underscore object.\n _.noConflict = function() {\n root._ = previousUnderscore;\n return this;\n };\n\n // Keep the identity function around for default iterators.\n _.identity = function(value) {\n return value;\n };\n\n // Run a function **n** times.\n _.times = function (n, iterator, context) {\n for (var i = 0; i < n; i++) iterator.call(context, i);\n };\n\n // Add your own custom functions to the Underscore object, ensuring that\n // they're correctly added to the OOP wrapper as well.\n _.mixin = function(obj) {\n each(_.functions(obj), function(name){\n addToWrapper(name, _[name] = obj[name]);\n });\n };\n\n // Generate a unique integer id (unique within the entire client session).\n // Useful for temporary DOM ids.\n var idCounter = 0;\n _.uniqueId = function(prefix) {\n var id = idCounter++;\n return prefix ? prefix + id : id;\n };\n\n // By default, Underscore uses ERB-style template delimiters, change the\n // following template settings to use alternative delimiters.\n _.templateSettings = {\n evaluate : /<%([\\s\\S]+?)%>/g,\n interpolate : /<%=([\\s\\S]+?)%>/g\n };\n\n // JavaScript micro-templating, similar to John Resig's implementation.\n // Underscore templating handles arbitrary delimiters, preserves whitespace,\n // and correctly escapes quotes within interpolated code.\n _.template = function(str, data) {\n var c = _.templateSettings;\n var tmpl = 'var __p=[],print=function(){__p.push.apply(__p,arguments);};' +\n 'with(obj||{}){__p.push(\\'' +\n str.replace(/\\\\/g, '\\\\\\\\')\n .replace(/'/g, \"\\\\'\")\n .replace(c.interpolate, function(match, code) {\n return \"',\" + code.replace(/\\\\'/g, \"'\") + \",'\";\n })\n .replace(c.evaluate || null, function(match, code) {\n return \"');\" + code.replace(/\\\\'/g, \"'\")\n .replace(/[\\r\\n\\t]/g, ' ') + \"__p.push('\";\n })\n .replace(/\\r/g, '\\\\r')\n .replace(/\\n/g, '\\\\n')\n .replace(/\\t/g, '\\\\t')\n + \"');}return __p.join('');\";\n var func = new Function('obj', tmpl);\n return data ? func(data) : func;\n };\n\n // The OOP Wrapper\n // ---------------\n\n // If Underscore is called as a function, it returns a wrapped object that\n // can be used OO-style. This wrapper holds altered versions of all the\n // underscore functions. Wrapped objects may be chained.\n var wrapper = function(obj) { this._wrapped = obj; };\n\n // Expose `wrapper.prototype` as `_.prototype`\n _.prototype = wrapper.prototype;\n\n // Helper function to continue chaining intermediate results.\n var result = function(obj, chain) {\n return chain ? _(obj).chain() : obj;\n };\n\n // A method to easily add functions to the OOP wrapper.\n var addToWrapper = function(name, func) {\n wrapper.prototype[name] = function() {\n var args = slice.call(arguments);\n unshift.call(args, this._wrapped);\n return result(func.apply(_, args), this._chain);\n };\n };\n\n // Add all of the Underscore functions to the wrapper object.\n _.mixin(_);\n\n // Add all mutator Array functions to the wrapper.\n each(['pop', 'push', 'reverse', 'shift', 'sort', 'splice', 'unshift'], function(name) {\n var method = ArrayProto[name];\n wrapper.prototype[name] = function() {\n method.apply(this._wrapped, arguments);\n return result(this._wrapped, this._chain);\n };\n });\n\n // Add all accessor Array functions to the wrapper.\n each(['concat', 'join', 'slice'], function(name) {\n var method = ArrayProto[name];\n wrapper.prototype[name] = function() {\n return result(method.apply(this._wrapped, arguments), this._chain);\n };\n });\n\n // Start chaining a wrapped Underscore object.\n wrapper.prototype.chain = function() {\n this._chain = true;\n return this;\n };\n\n // Extracts the result from a wrapped and chained object.\n wrapper.prototype.value = function() {\n return this._wrapped;\n };\n\n})();" }, { "path": "test/zepto.html", "content": "\n\n
\n