update jshint
This commit is contained in:
nightwing
parent
2cb84b3bc3
commit
4e2d7a41f5
2 changed files with 365 additions and 179 deletions
|
|
@ -27,9 +27,9 @@ module.exports = {
|
|||
},
|
||||
{}],
|
||||
2:[function(_dereq_,module,exports){
|
||||
// Underscore.js 1.4.4
|
||||
// Underscore.js 1.6.0
|
||||
// http://underscorejs.org
|
||||
// (c) 2009-2013 Jeremy Ashkenas, DocumentCloud Inc.
|
||||
// (c) 2009-2014 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
|
||||
// Underscore may be freely distributed under the MIT license.
|
||||
|
||||
(function() {
|
||||
|
|
@ -37,7 +37,7 @@ module.exports = {
|
|||
// Baseline setup
|
||||
// --------------
|
||||
|
||||
// Establish the root object, `window` in the browser, or `global` on the server.
|
||||
// Establish the root object, `window` in the browser, or `exports` on the server.
|
||||
var root = this;
|
||||
|
||||
// Save the previous value of the `_` variable.
|
||||
|
|
@ -50,7 +50,8 @@ module.exports = {
|
|||
var ArrayProto = Array.prototype, ObjProto = Object.prototype, FuncProto = Function.prototype;
|
||||
|
||||
// Create quick reference variables for speed access to core prototypes.
|
||||
var push = ArrayProto.push,
|
||||
var
|
||||
push = ArrayProto.push,
|
||||
slice = ArrayProto.slice,
|
||||
concat = ArrayProto.concat,
|
||||
toString = ObjProto.toString,
|
||||
|
|
@ -93,7 +94,7 @@ module.exports = {
|
|||
}
|
||||
|
||||
// Current version.
|
||||
_.VERSION = '1.4.4';
|
||||
_.VERSION = '1.6.0';
|
||||
|
||||
// Collection Functions
|
||||
// --------------------
|
||||
|
|
@ -102,20 +103,20 @@ module.exports = {
|
|||
// Handles objects with the built-in `forEach`, arrays, and raw objects.
|
||||
// Delegates to **ECMAScript 5**'s native `forEach` if available.
|
||||
var each = _.each = _.forEach = function(obj, iterator, context) {
|
||||
if (obj == null) return;
|
||||
if (obj == null) return obj;
|
||||
if (nativeForEach && obj.forEach === nativeForEach) {
|
||||
obj.forEach(iterator, context);
|
||||
} else if (obj.length === +obj.length) {
|
||||
for (var i = 0, l = obj.length; i < l; i++) {
|
||||
for (var i = 0, length = obj.length; i < length; i++) {
|
||||
if (iterator.call(context, obj[i], i, obj) === breaker) return;
|
||||
}
|
||||
} else {
|
||||
for (var key in obj) {
|
||||
if (_.has(obj, key)) {
|
||||
if (iterator.call(context, obj[key], key, obj) === breaker) return;
|
||||
}
|
||||
var keys = _.keys(obj);
|
||||
for (var i = 0, length = keys.length; i < length; i++) {
|
||||
if (iterator.call(context, obj[keys[i]], keys[i], obj) === breaker) return;
|
||||
}
|
||||
}
|
||||
return obj;
|
||||
};
|
||||
|
||||
// Return the results of applying the iterator to each element.
|
||||
|
|
@ -125,7 +126,7 @@ module.exports = {
|
|||
if (obj == null) return results;
|
||||
if (nativeMap && obj.map === nativeMap) return obj.map(iterator, context);
|
||||
each(obj, function(value, index, list) {
|
||||
results[results.length] = iterator.call(context, value, index, list);
|
||||
results.push(iterator.call(context, value, index, list));
|
||||
});
|
||||
return results;
|
||||
};
|
||||
|
|
@ -181,10 +182,10 @@ module.exports = {
|
|||
};
|
||||
|
||||
// Return the first value which passes a truth test. Aliased as `detect`.
|
||||
_.find = _.detect = function(obj, iterator, context) {
|
||||
_.find = _.detect = function(obj, predicate, context) {
|
||||
var result;
|
||||
any(obj, function(value, index, list) {
|
||||
if (iterator.call(context, value, index, list)) {
|
||||
if (predicate.call(context, value, index, list)) {
|
||||
result = value;
|
||||
return true;
|
||||
}
|
||||
|
|
@ -195,33 +196,33 @@ module.exports = {
|
|||
// Return all the elements that pass a truth test.
|
||||
// Delegates to **ECMAScript 5**'s native `filter` if available.
|
||||
// Aliased as `select`.
|
||||
_.filter = _.select = function(obj, iterator, context) {
|
||||
_.filter = _.select = function(obj, predicate, context) {
|
||||
var results = [];
|
||||
if (obj == null) return results;
|
||||
if (nativeFilter && obj.filter === nativeFilter) return obj.filter(iterator, context);
|
||||
if (nativeFilter && obj.filter === nativeFilter) return obj.filter(predicate, context);
|
||||
each(obj, function(value, index, list) {
|
||||
if (iterator.call(context, value, index, list)) results[results.length] = value;
|
||||
if (predicate.call(context, value, index, list)) results.push(value);
|
||||
});
|
||||
return results;
|
||||
};
|
||||
|
||||
// Return all the elements for which a truth test fails.
|
||||
_.reject = function(obj, iterator, context) {
|
||||
_.reject = function(obj, predicate, context) {
|
||||
return _.filter(obj, function(value, index, list) {
|
||||
return !iterator.call(context, value, index, list);
|
||||
return !predicate.call(context, value, index, list);
|
||||
}, context);
|
||||
};
|
||||
|
||||
// Determine whether all of the elements match a truth test.
|
||||
// Delegates to **ECMAScript 5**'s native `every` if available.
|
||||
// Aliased as `all`.
|
||||
_.every = _.all = function(obj, iterator, context) {
|
||||
iterator || (iterator = _.identity);
|
||||
_.every = _.all = function(obj, predicate, context) {
|
||||
predicate || (predicate = _.identity);
|
||||
var result = true;
|
||||
if (obj == null) return result;
|
||||
if (nativeEvery && obj.every === nativeEvery) return obj.every(iterator, context);
|
||||
if (nativeEvery && obj.every === nativeEvery) return obj.every(predicate, context);
|
||||
each(obj, function(value, index, list) {
|
||||
if (!(result = result && iterator.call(context, value, index, list))) return breaker;
|
||||
if (!(result = result && predicate.call(context, value, index, list))) return breaker;
|
||||
});
|
||||
return !!result;
|
||||
};
|
||||
|
|
@ -229,13 +230,13 @@ module.exports = {
|
|||
// Determine if at least one element in the object matches a truth test.
|
||||
// Delegates to **ECMAScript 5**'s native `some` if available.
|
||||
// Aliased as `any`.
|
||||
var any = _.some = _.any = function(obj, iterator, context) {
|
||||
iterator || (iterator = _.identity);
|
||||
var any = _.some = _.any = function(obj, predicate, context) {
|
||||
predicate || (predicate = _.identity);
|
||||
var result = false;
|
||||
if (obj == null) return result;
|
||||
if (nativeSome && obj.some === nativeSome) return obj.some(iterator, context);
|
||||
if (nativeSome && obj.some === nativeSome) return obj.some(predicate, context);
|
||||
each(obj, function(value, index, list) {
|
||||
if (result || (result = iterator.call(context, value, index, list))) return breaker;
|
||||
if (result || (result = predicate.call(context, value, index, list))) return breaker;
|
||||
});
|
||||
return !!result;
|
||||
};
|
||||
|
|
@ -261,41 +262,37 @@ module.exports = {
|
|||
|
||||
// Convenience version of a common use case of `map`: fetching a property.
|
||||
_.pluck = function(obj, key) {
|
||||
return _.map(obj, function(value){ return value[key]; });
|
||||
return _.map(obj, _.property(key));
|
||||
};
|
||||
|
||||
// Convenience version of a common use case of `filter`: selecting only objects
|
||||
// containing specific `key:value` pairs.
|
||||
_.where = function(obj, attrs, first) {
|
||||
if (_.isEmpty(attrs)) return first ? null : [];
|
||||
return _[first ? 'find' : 'filter'](obj, function(value) {
|
||||
for (var key in attrs) {
|
||||
if (attrs[key] !== value[key]) return false;
|
||||
}
|
||||
return true;
|
||||
});
|
||||
_.where = function(obj, attrs) {
|
||||
return _.filter(obj, _.matches(attrs));
|
||||
};
|
||||
|
||||
// Convenience version of a common use case of `find`: getting the first object
|
||||
// containing specific `key:value` pairs.
|
||||
_.findWhere = function(obj, attrs) {
|
||||
return _.where(obj, attrs, true);
|
||||
return _.find(obj, _.matches(attrs));
|
||||
};
|
||||
|
||||
// Return the maximum element or (element-based computation).
|
||||
// Can't optimize arrays of integers longer than 65,535 elements.
|
||||
// See: https://bugs.webkit.org/show_bug.cgi?id=80797
|
||||
// See [WebKit Bug 80797](https://bugs.webkit.org/show_bug.cgi?id=80797)
|
||||
_.max = function(obj, iterator, context) {
|
||||
if (!iterator && _.isArray(obj) && obj[0] === +obj[0] && obj.length < 65535) {
|
||||
return Math.max.apply(Math, obj);
|
||||
}
|
||||
if (!iterator && _.isEmpty(obj)) return -Infinity;
|
||||
var result = {computed : -Infinity, value: -Infinity};
|
||||
var result = -Infinity, lastComputed = -Infinity;
|
||||
each(obj, function(value, index, list) {
|
||||
var computed = iterator ? iterator.call(context, value, index, list) : value;
|
||||
computed >= result.computed && (result = {value : value, computed : computed});
|
||||
if (computed > lastComputed) {
|
||||
result = value;
|
||||
lastComputed = computed;
|
||||
}
|
||||
});
|
||||
return result.value;
|
||||
return result;
|
||||
};
|
||||
|
||||
// Return the minimum element (or element-based computation).
|
||||
|
|
@ -303,16 +300,19 @@ module.exports = {
|
|||
if (!iterator && _.isArray(obj) && obj[0] === +obj[0] && obj.length < 65535) {
|
||||
return Math.min.apply(Math, obj);
|
||||
}
|
||||
if (!iterator && _.isEmpty(obj)) return Infinity;
|
||||
var result = {computed : Infinity, value: Infinity};
|
||||
var result = Infinity, lastComputed = Infinity;
|
||||
each(obj, function(value, index, list) {
|
||||
var computed = iterator ? iterator.call(context, value, index, list) : value;
|
||||
computed < result.computed && (result = {value : value, computed : computed});
|
||||
if (computed < lastComputed) {
|
||||
result = value;
|
||||
lastComputed = computed;
|
||||
}
|
||||
});
|
||||
return result.value;
|
||||
return result;
|
||||
};
|
||||
|
||||
// Shuffle an array.
|
||||
// Shuffle an array, using the modern version of the
|
||||
// [Fisher-Yates shuffle](http://en.wikipedia.org/wiki/Fisher–Yates_shuffle).
|
||||
_.shuffle = function(obj) {
|
||||
var rand;
|
||||
var index = 0;
|
||||
|
|
@ -325,14 +325,27 @@ module.exports = {
|
|||
return shuffled;
|
||||
};
|
||||
|
||||
// Sample **n** random values from a collection.
|
||||
// If **n** is not specified, returns a single random element.
|
||||
// The internal `guard` argument allows it to work with `map`.
|
||||
_.sample = function(obj, n, guard) {
|
||||
if (n == null || guard) {
|
||||
if (obj.length !== +obj.length) obj = _.values(obj);
|
||||
return obj[_.random(obj.length - 1)];
|
||||
}
|
||||
return _.shuffle(obj).slice(0, Math.max(0, n));
|
||||
};
|
||||
|
||||
// An internal function to generate lookup iterators.
|
||||
var lookupIterator = function(value) {
|
||||
return _.isFunction(value) ? value : function(obj){ return obj[value]; };
|
||||
if (value == null) return _.identity;
|
||||
if (_.isFunction(value)) return value;
|
||||
return _.property(value);
|
||||
};
|
||||
|
||||
// Sort the object's values by a criterion produced by an iterator.
|
||||
_.sortBy = function(obj, value, context) {
|
||||
var iterator = lookupIterator(value);
|
||||
_.sortBy = function(obj, iterator, context) {
|
||||
iterator = lookupIterator(iterator);
|
||||
return _.pluck(_.map(obj, function(value, index, list) {
|
||||
return {
|
||||
value: value,
|
||||
|
|
@ -346,43 +359,46 @@ module.exports = {
|
|||
if (a > b || a === void 0) return 1;
|
||||
if (a < b || b === void 0) return -1;
|
||||
}
|
||||
return left.index < right.index ? -1 : 1;
|
||||
return left.index - right.index;
|
||||
}), 'value');
|
||||
};
|
||||
|
||||
// An internal function used for aggregate "group by" operations.
|
||||
var group = function(obj, value, context, behavior) {
|
||||
var group = function(behavior) {
|
||||
return function(obj, iterator, context) {
|
||||
var result = {};
|
||||
var iterator = lookupIterator(value || _.identity);
|
||||
iterator = lookupIterator(iterator);
|
||||
each(obj, function(value, index) {
|
||||
var key = iterator.call(context, value, index, obj);
|
||||
behavior(result, key, value);
|
||||
});
|
||||
return result;
|
||||
};
|
||||
};
|
||||
|
||||
// Groups the object's values by a criterion. Pass either a string attribute
|
||||
// to group by, or a function that returns the criterion.
|
||||
_.groupBy = function(obj, value, context) {
|
||||
return group(obj, value, context, function(result, key, value) {
|
||||
(_.has(result, key) ? result[key] : (result[key] = [])).push(value);
|
||||
_.groupBy = group(function(result, key, value) {
|
||||
_.has(result, key) ? result[key].push(value) : result[key] = [value];
|
||||
});
|
||||
|
||||
// Indexes the object's values by a criterion, similar to `groupBy`, but for
|
||||
// when you know that your index values will be unique.
|
||||
_.indexBy = group(function(result, key, value) {
|
||||
result[key] = value;
|
||||
});
|
||||
};
|
||||
|
||||
// Counts instances of an object that group by a certain criterion. Pass
|
||||
// either a string attribute to count by, or a function that returns the
|
||||
// criterion.
|
||||
_.countBy = function(obj, value, context) {
|
||||
return group(obj, value, context, function(result, key) {
|
||||
if (!_.has(result, key)) result[key] = 0;
|
||||
result[key]++;
|
||||
_.countBy = group(function(result, key) {
|
||||
_.has(result, key) ? result[key]++ : result[key] = 1;
|
||||
});
|
||||
};
|
||||
|
||||
// Use a comparator function to figure out the smallest index at which
|
||||
// an object should be inserted so as to maintain order. Uses binary search.
|
||||
_.sortedIndex = function(array, obj, iterator, context) {
|
||||
iterator = iterator == null ? _.identity : lookupIterator(iterator);
|
||||
iterator = lookupIterator(iterator);
|
||||
var value = iterator.call(context, obj);
|
||||
var low = 0, high = array.length;
|
||||
while (low < high) {
|
||||
|
|
@ -392,7 +408,7 @@ module.exports = {
|
|||
return low;
|
||||
};
|
||||
|
||||
// Safely convert anything iterable into a real, live array.
|
||||
// Safely create a real, live array from anything iterable.
|
||||
_.toArray = function(obj) {
|
||||
if (!obj) return [];
|
||||
if (_.isArray(obj)) return slice.call(obj);
|
||||
|
|
@ -414,7 +430,9 @@ module.exports = {
|
|||
// allows it to work with `_.map`.
|
||||
_.first = _.head = _.take = function(array, n, guard) {
|
||||
if (array == null) return void 0;
|
||||
return (n != null) && !guard ? slice.call(array, 0, n) : array[0];
|
||||
if ((n == null) || guard) return array[0];
|
||||
if (n < 0) return [];
|
||||
return slice.call(array, 0, n);
|
||||
};
|
||||
|
||||
// Returns everything but the last entry of the array. Especially useful on
|
||||
|
|
@ -429,11 +447,8 @@ module.exports = {
|
|||
// values in the array. The **guard** check allows it to work with `_.map`.
|
||||
_.last = function(array, n, guard) {
|
||||
if (array == null) return void 0;
|
||||
if ((n != null) && !guard) {
|
||||
if ((n == null) || guard) return array[array.length - 1];
|
||||
return slice.call(array, Math.max(array.length - n, 0));
|
||||
} else {
|
||||
return array[array.length - 1];
|
||||
}
|
||||
};
|
||||
|
||||
// Returns everything but the first entry of the array. Aliased as `tail` and `drop`.
|
||||
|
|
@ -451,8 +466,11 @@ module.exports = {
|
|||
|
||||
// Internal implementation of a recursive `flatten` function.
|
||||
var flatten = function(input, shallow, output) {
|
||||
if (shallow && _.every(input, _.isArray)) {
|
||||
return concat.apply(output, input);
|
||||
}
|
||||
each(input, function(value) {
|
||||
if (_.isArray(value)) {
|
||||
if (_.isArray(value) || _.isArguments(value)) {
|
||||
shallow ? push.apply(output, value) : flatten(value, shallow, output);
|
||||
} else {
|
||||
output.push(value);
|
||||
|
|
@ -461,7 +479,7 @@ module.exports = {
|
|||
return output;
|
||||
};
|
||||
|
||||
// Return a completely flattened version of an array.
|
||||
// Flatten out an array, either recursively (by default), or just one level.
|
||||
_.flatten = function(array, shallow) {
|
||||
return flatten(array, shallow, []);
|
||||
};
|
||||
|
|
@ -471,6 +489,16 @@ module.exports = {
|
|||
return _.difference(array, slice.call(arguments, 1));
|
||||
};
|
||||
|
||||
// Split an array into two arrays: one whose elements all satisfy the given
|
||||
// predicate, and one whose elements all do not satisfy the predicate.
|
||||
_.partition = function(array, predicate) {
|
||||
var pass = [], fail = [];
|
||||
each(array, function(elem) {
|
||||
(predicate(elem) ? pass : fail).push(elem);
|
||||
});
|
||||
return [pass, fail];
|
||||
};
|
||||
|
||||
// Produce a duplicate-free version of the array. If the array has already
|
||||
// been sorted, you have the option of using a faster algorithm.
|
||||
// Aliased as `unique`.
|
||||
|
|
@ -495,7 +523,7 @@ module.exports = {
|
|||
// Produce an array that contains the union: each distinct element from all of
|
||||
// the passed-in arrays.
|
||||
_.union = function() {
|
||||
return _.uniq(concat.apply(ArrayProto, arguments));
|
||||
return _.uniq(_.flatten(arguments, true));
|
||||
};
|
||||
|
||||
// Produce an array that contains every item shared between all the
|
||||
|
|
@ -504,7 +532,7 @@ module.exports = {
|
|||
var rest = slice.call(arguments, 1);
|
||||
return _.filter(_.uniq(array), function(item) {
|
||||
return _.every(rest, function(other) {
|
||||
return _.indexOf(other, item) >= 0;
|
||||
return _.contains(other, item);
|
||||
});
|
||||
});
|
||||
};
|
||||
|
|
@ -519,11 +547,10 @@ module.exports = {
|
|||
// Zip together multiple lists into a single array -- elements that share
|
||||
// an index go together.
|
||||
_.zip = function() {
|
||||
var args = slice.call(arguments);
|
||||
var length = _.max(_.pluck(args, 'length'));
|
||||
var length = _.max(_.pluck(arguments, 'length').concat(0));
|
||||
var results = new Array(length);
|
||||
for (var i = 0; i < length; i++) {
|
||||
results[i] = _.pluck(args, "" + i);
|
||||
results[i] = _.pluck(arguments, '' + i);
|
||||
}
|
||||
return results;
|
||||
};
|
||||
|
|
@ -534,7 +561,7 @@ module.exports = {
|
|||
_.object = function(list, values) {
|
||||
if (list == null) return {};
|
||||
var result = {};
|
||||
for (var i = 0, l = list.length; i < l; i++) {
|
||||
for (var i = 0, length = list.length; i < length; i++) {
|
||||
if (values) {
|
||||
result[list[i]] = values[i];
|
||||
} else {
|
||||
|
|
@ -552,17 +579,17 @@ module.exports = {
|
|||
// for **isSorted** to use binary search.
|
||||
_.indexOf = function(array, item, isSorted) {
|
||||
if (array == null) return -1;
|
||||
var i = 0, l = array.length;
|
||||
var i = 0, length = array.length;
|
||||
if (isSorted) {
|
||||
if (typeof isSorted == 'number') {
|
||||
i = (isSorted < 0 ? Math.max(0, l + isSorted) : isSorted);
|
||||
i = (isSorted < 0 ? Math.max(0, length + isSorted) : isSorted);
|
||||
} else {
|
||||
i = _.sortedIndex(array, item);
|
||||
return array[i] === item ? i : -1;
|
||||
}
|
||||
}
|
||||
if (nativeIndexOf && array.indexOf === nativeIndexOf) return array.indexOf(item, isSorted);
|
||||
for (; i < l; i++) if (array[i] === item) return i;
|
||||
for (; i < length; i++) if (array[i] === item) return i;
|
||||
return -1;
|
||||
};
|
||||
|
||||
|
|
@ -588,11 +615,11 @@ module.exports = {
|
|||
}
|
||||
step = arguments[2] || 1;
|
||||
|
||||
var len = Math.max(Math.ceil((stop - start) / step), 0);
|
||||
var length = Math.max(Math.ceil((stop - start) / step), 0);
|
||||
var idx = 0;
|
||||
var range = new Array(len);
|
||||
var range = new Array(length);
|
||||
|
||||
while(idx < len) {
|
||||
while(idx < length) {
|
||||
range[idx++] = start;
|
||||
start += step;
|
||||
}
|
||||
|
|
@ -603,31 +630,50 @@ module.exports = {
|
|||
// Function (ahem) Functions
|
||||
// ------------------
|
||||
|
||||
// Reusable constructor function for prototype setting.
|
||||
var ctor = function(){};
|
||||
|
||||
// Create a function bound to a given object (assigning `this`, and arguments,
|
||||
// optionally). Delegates to **ECMAScript 5**'s native `Function.bind` if
|
||||
// available.
|
||||
_.bind = function(func, context) {
|
||||
if (func.bind === nativeBind && nativeBind) return nativeBind.apply(func, slice.call(arguments, 1));
|
||||
var args = slice.call(arguments, 2);
|
||||
return function() {
|
||||
return func.apply(context, args.concat(slice.call(arguments)));
|
||||
var args, bound;
|
||||
if (nativeBind && func.bind === nativeBind) return nativeBind.apply(func, slice.call(arguments, 1));
|
||||
if (!_.isFunction(func)) throw new TypeError;
|
||||
args = slice.call(arguments, 2);
|
||||
return bound = function() {
|
||||
if (!(this instanceof bound)) return func.apply(context, args.concat(slice.call(arguments)));
|
||||
ctor.prototype = func.prototype;
|
||||
var self = new ctor;
|
||||
ctor.prototype = null;
|
||||
var result = func.apply(self, args.concat(slice.call(arguments)));
|
||||
if (Object(result) === result) return result;
|
||||
return self;
|
||||
};
|
||||
};
|
||||
|
||||
// Partially apply a function by creating a version that has had some of its
|
||||
// arguments pre-filled, without changing its dynamic `this` context.
|
||||
// arguments pre-filled, without changing its dynamic `this` context. _ acts
|
||||
// as a placeholder, allowing any combination of arguments to be pre-filled.
|
||||
_.partial = function(func) {
|
||||
var args = slice.call(arguments, 1);
|
||||
var boundArgs = slice.call(arguments, 1);
|
||||
return function() {
|
||||
return func.apply(this, args.concat(slice.call(arguments)));
|
||||
var position = 0;
|
||||
var args = boundArgs.slice();
|
||||
for (var i = 0, length = args.length; i < length; i++) {
|
||||
if (args[i] === _) args[i] = arguments[position++];
|
||||
}
|
||||
while (position < arguments.length) args.push(arguments[position++]);
|
||||
return func.apply(this, args);
|
||||
};
|
||||
};
|
||||
|
||||
// Bind all of an object's methods to that object. Useful for ensuring that
|
||||
// all callbacks defined on an object belong to it.
|
||||
// Bind a number of an object's methods to that object. Remaining arguments
|
||||
// are the method names to be bound. Useful for ensuring that all callbacks
|
||||
// defined on an object belong to it.
|
||||
_.bindAll = function(obj) {
|
||||
var funcs = slice.call(arguments, 1);
|
||||
if (funcs.length === 0) funcs = _.functions(obj);
|
||||
if (funcs.length === 0) throw new Error('bindAll must be passed function names');
|
||||
each(funcs, function(f) { obj[f] = _.bind(obj[f], obj); });
|
||||
return obj;
|
||||
};
|
||||
|
|
@ -656,17 +702,24 @@ module.exports = {
|
|||
};
|
||||
|
||||
// Returns a function, that, when invoked, will only be triggered at most once
|
||||
// during a given window of time.
|
||||
_.throttle = function(func, wait) {
|
||||
var context, args, timeout, result;
|
||||
// during a given window of time. Normally, the throttled function will run
|
||||
// as much as it can, without ever going more than once per `wait` duration;
|
||||
// but if you'd like to disable the execution on the leading edge, pass
|
||||
// `{leading: false}`. To disable execution on the trailing edge, ditto.
|
||||
_.throttle = function(func, wait, options) {
|
||||
var context, args, result;
|
||||
var timeout = null;
|
||||
var previous = 0;
|
||||
options || (options = {});
|
||||
var later = function() {
|
||||
previous = new Date;
|
||||
previous = options.leading === false ? 0 : _.now();
|
||||
timeout = null;
|
||||
result = func.apply(context, args);
|
||||
context = args = null;
|
||||
};
|
||||
return function() {
|
||||
var now = new Date;
|
||||
var now = _.now();
|
||||
if (!previous && options.leading === false) previous = now;
|
||||
var remaining = wait - (now - previous);
|
||||
context = this;
|
||||
args = arguments;
|
||||
|
|
@ -675,7 +728,8 @@ module.exports = {
|
|||
timeout = null;
|
||||
previous = now;
|
||||
result = func.apply(context, args);
|
||||
} else if (!timeout) {
|
||||
context = args = null;
|
||||
} else if (!timeout && options.trailing !== false) {
|
||||
timeout = setTimeout(later, remaining);
|
||||
}
|
||||
return result;
|
||||
|
|
@ -687,17 +741,34 @@ module.exports = {
|
|||
// N milliseconds. If `immediate` is passed, trigger the function on the
|
||||
// leading edge, instead of the trailing.
|
||||
_.debounce = function(func, wait, immediate) {
|
||||
var timeout, result;
|
||||
return function() {
|
||||
var context = this, args = arguments;
|
||||
var timeout, args, context, timestamp, result;
|
||||
|
||||
var later = function() {
|
||||
var last = _.now() - timestamp;
|
||||
if (last < wait) {
|
||||
timeout = setTimeout(later, wait - last);
|
||||
} else {
|
||||
timeout = null;
|
||||
if (!immediate) result = func.apply(context, args);
|
||||
if (!immediate) {
|
||||
result = func.apply(context, args);
|
||||
context = args = null;
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
return function() {
|
||||
context = this;
|
||||
args = arguments;
|
||||
timestamp = _.now();
|
||||
var callNow = immediate && !timeout;
|
||||
clearTimeout(timeout);
|
||||
if (!timeout) {
|
||||
timeout = setTimeout(later, wait);
|
||||
if (callNow) result = func.apply(context, args);
|
||||
}
|
||||
if (callNow) {
|
||||
result = func.apply(context, args);
|
||||
context = args = null;
|
||||
}
|
||||
|
||||
return result;
|
||||
};
|
||||
};
|
||||
|
|
@ -719,11 +790,7 @@ module.exports = {
|
|||
// allowing you to adjust arguments, run code before and after, and
|
||||
// conditionally execute the original function.
|
||||
_.wrap = function(func, wrapper) {
|
||||
return function() {
|
||||
var args = [func];
|
||||
push.apply(args, arguments);
|
||||
return wrapper.apply(this, args);
|
||||
};
|
||||
return _.partial(wrapper, func);
|
||||
};
|
||||
|
||||
// Returns a function that is the composition of a list of functions, each
|
||||
|
|
@ -741,7 +808,6 @@ module.exports = {
|
|||
|
||||
// Returns a function that will only be executed after being called N times.
|
||||
_.after = function(times, func) {
|
||||
if (times <= 0) return func();
|
||||
return function() {
|
||||
if (--times < 1) {
|
||||
return func.apply(this, arguments);
|
||||
|
|
@ -754,31 +820,43 @@ module.exports = {
|
|||
|
||||
// Retrieve the names of an object's properties.
|
||||
// Delegates to **ECMAScript 5**'s native `Object.keys`
|
||||
_.keys = nativeKeys || function(obj) {
|
||||
if (obj !== Object(obj)) throw new TypeError('Invalid object');
|
||||
_.keys = function(obj) {
|
||||
if (!_.isObject(obj)) return [];
|
||||
if (nativeKeys) return nativeKeys(obj);
|
||||
var keys = [];
|
||||
for (var key in obj) if (_.has(obj, key)) keys[keys.length] = key;
|
||||
for (var key in obj) if (_.has(obj, key)) keys.push(key);
|
||||
return keys;
|
||||
};
|
||||
|
||||
// Retrieve the values of an object's properties.
|
||||
_.values = function(obj) {
|
||||
var values = [];
|
||||
for (var key in obj) if (_.has(obj, key)) values.push(obj[key]);
|
||||
var keys = _.keys(obj);
|
||||
var length = keys.length;
|
||||
var values = new Array(length);
|
||||
for (var i = 0; i < length; i++) {
|
||||
values[i] = obj[keys[i]];
|
||||
}
|
||||
return values;
|
||||
};
|
||||
|
||||
// Convert an object into a list of `[key, value]` pairs.
|
||||
_.pairs = function(obj) {
|
||||
var pairs = [];
|
||||
for (var key in obj) if (_.has(obj, key)) pairs.push([key, obj[key]]);
|
||||
var keys = _.keys(obj);
|
||||
var length = keys.length;
|
||||
var pairs = new Array(length);
|
||||
for (var i = 0; i < length; i++) {
|
||||
pairs[i] = [keys[i], obj[keys[i]]];
|
||||
}
|
||||
return pairs;
|
||||
};
|
||||
|
||||
// Invert the keys and values of an object. The values must be serializable.
|
||||
_.invert = function(obj) {
|
||||
var result = {};
|
||||
for (var key in obj) if (_.has(obj, key)) result[obj[key]] = key;
|
||||
var keys = _.keys(obj);
|
||||
for (var i = 0, length = keys.length; i < length; i++) {
|
||||
result[obj[keys[i]]] = keys[i];
|
||||
}
|
||||
return result;
|
||||
};
|
||||
|
||||
|
|
@ -829,7 +907,7 @@ module.exports = {
|
|||
each(slice.call(arguments, 1), function(source) {
|
||||
if (source) {
|
||||
for (var prop in source) {
|
||||
if (obj[prop] == null) obj[prop] = source[prop];
|
||||
if (obj[prop] === void 0) obj[prop] = source[prop];
|
||||
}
|
||||
}
|
||||
});
|
||||
|
|
@ -853,7 +931,7 @@ module.exports = {
|
|||
// Internal recursive comparison function for `isEqual`.
|
||||
var eq = function(a, b, aStack, bStack) {
|
||||
// Identical objects are equal. `0 === -0`, but they aren't identical.
|
||||
// See the Harmony `egal` proposal: http://wiki.ecmascript.org/doku.php?id=harmony:egal.
|
||||
// See the [Harmony `egal` proposal](http://wiki.ecmascript.org/doku.php?id=harmony:egal).
|
||||
if (a === b) return a !== 0 || 1 / a == 1 / b;
|
||||
// A strict comparison is necessary because `null == undefined`.
|
||||
if (a == null || b == null) return a === b;
|
||||
|
|
@ -895,6 +973,14 @@ module.exports = {
|
|||
// unique nested structures.
|
||||
if (aStack[length] == a) return bStack[length] == b;
|
||||
}
|
||||
// Objects with different constructors are not equivalent, but `Object`s
|
||||
// from different frames are.
|
||||
var aCtor = a.constructor, bCtor = b.constructor;
|
||||
if (aCtor !== bCtor && !(_.isFunction(aCtor) && (aCtor instanceof aCtor) &&
|
||||
_.isFunction(bCtor) && (bCtor instanceof bCtor))
|
||||
&& ('constructor' in a && 'constructor' in b)) {
|
||||
return false;
|
||||
}
|
||||
// Add the first object to the stack of traversed objects.
|
||||
aStack.push(a);
|
||||
bStack.push(b);
|
||||
|
|
@ -911,13 +997,6 @@ module.exports = {
|
|||
}
|
||||
}
|
||||
} else {
|
||||
// Objects with different constructors are not equivalent, but `Object`s
|
||||
// from different frames are.
|
||||
var aCtor = a.constructor, bCtor = b.constructor;
|
||||
if (aCtor !== bCtor && !(_.isFunction(aCtor) && (aCtor instanceof aCtor) &&
|
||||
_.isFunction(bCtor) && (bCtor instanceof bCtor))) {
|
||||
return false;
|
||||
}
|
||||
// Deep compare objects.
|
||||
for (var key in a) {
|
||||
if (_.has(a, key)) {
|
||||
|
|
@ -1039,9 +1118,33 @@ module.exports = {
|
|||
return value;
|
||||
};
|
||||
|
||||
_.constant = function(value) {
|
||||
return function () {
|
||||
return value;
|
||||
};
|
||||
};
|
||||
|
||||
_.property = function(key) {
|
||||
return function(obj) {
|
||||
return obj[key];
|
||||
};
|
||||
};
|
||||
|
||||
// Returns a predicate for checking whether an object has a given set of `key:value` pairs.
|
||||
_.matches = function(attrs) {
|
||||
return function(obj) {
|
||||
if (obj === attrs) return true; //avoid comparing an object to itself.
|
||||
for (var key in attrs) {
|
||||
if (attrs[key] !== obj[key])
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
};
|
||||
|
||||
// Run a function **n** times.
|
||||
_.times = function(n, iterator, context) {
|
||||
var accum = Array(n);
|
||||
var accum = Array(Math.max(0, n));
|
||||
for (var i = 0; i < n; i++) accum[i] = iterator.call(context, i);
|
||||
return accum;
|
||||
};
|
||||
|
|
@ -1055,6 +1158,9 @@ module.exports = {
|
|||
return min + Math.floor(Math.random() * (max - min + 1));
|
||||
};
|
||||
|
||||
// A (possibly faster) way to get the current timestamp as an integer.
|
||||
_.now = Date.now || function() { return new Date().getTime(); };
|
||||
|
||||
// List of HTML entities for escaping.
|
||||
var entityMap = {
|
||||
escape: {
|
||||
|
|
@ -1062,8 +1168,7 @@ module.exports = {
|
|||
'<': '<',
|
||||
'>': '>',
|
||||
'"': '"',
|
||||
"'": ''',
|
||||
'/': '/'
|
||||
"'": '''
|
||||
}
|
||||
};
|
||||
entityMap.unescape = _.invert(entityMap.escape);
|
||||
|
|
@ -1084,10 +1189,10 @@ module.exports = {
|
|||
};
|
||||
});
|
||||
|
||||
// If the value of the named property is a function then invoke it;
|
||||
// otherwise, return it.
|
||||
// If the value of the named `property` is a function then invoke it with the
|
||||
// `object` as context; otherwise, return it.
|
||||
_.result = function(object, property) {
|
||||
if (object == null) return null;
|
||||
if (object == null) return void 0;
|
||||
var value = object[property];
|
||||
return _.isFunction(value) ? value.call(object) : value;
|
||||
};
|
||||
|
|
@ -1252,6 +1357,18 @@ module.exports = {
|
|||
|
||||
});
|
||||
|
||||
// AMD registration happens at the end for compatibility with AMD loaders
|
||||
// that may not enforce next-turn semantics on modules. Even though general
|
||||
// practice for AMD registration is to be anonymous, underscore registers
|
||||
// as a named module because, like jQuery, it is a base library that is
|
||||
// popular enough to be bundled in a third party lib, but not be part of
|
||||
// an AMD load request. Those cases could generate an error when an
|
||||
// anonymous define() is called outside of a loader request.
|
||||
if (typeof define === 'function' && define.amd) {
|
||||
define('underscore', [], function() {
|
||||
return _;
|
||||
});
|
||||
}
|
||||
}).call(this);
|
||||
|
||||
},
|
||||
|
|
@ -1353,6 +1470,7 @@ var JSHINT = (function () {
|
|||
globalstrict: true, // if global "use strict"; should be allowed (also enables 'strict')
|
||||
immed : true, // if immediate invocations must be wrapped in parens
|
||||
iterator : true, // if the `__iterator__` property should be allowed
|
||||
jasmine : true, // Jasmine functions should be predefined
|
||||
jquery : true, // if jQuery globals should be predefined
|
||||
lastsemic : true, // if semicolons may be ommitted for the trailing
|
||||
// statements inside of a one-line blocks.
|
||||
|
|
@ -1378,6 +1496,7 @@ var JSHINT = (function () {
|
|||
proto : true, // if the `__proto__` property should be allowed
|
||||
prototypejs : true, // if Prototype and Scriptaculous globals should be
|
||||
// predefined
|
||||
qunit : true, // if the QUnit environment globals should be predefined
|
||||
rhino : true, // if the Rhino environment globals should be predefined
|
||||
shelljs : true, // if ShellJS globals should be predefined
|
||||
typed : true, // if typed array globals should be predefined
|
||||
|
|
@ -1570,7 +1689,7 @@ var JSHINT = (function () {
|
|||
|
||||
function combine(dest, src) {
|
||||
Object.keys(src).forEach(function (name) {
|
||||
if (JSHINT.blacklist.hasOwnProperty(name)) return;
|
||||
if (_.has(JSHINT.blacklist, name)) return;
|
||||
dest[name] = src[name];
|
||||
});
|
||||
}
|
||||
|
|
@ -1584,6 +1703,10 @@ var JSHINT = (function () {
|
|||
combine(predefined, vars.couch);
|
||||
}
|
||||
|
||||
if (state.option.qunit) {
|
||||
combine(predefined, vars.qunit);
|
||||
}
|
||||
|
||||
if (state.option.rhino) {
|
||||
combine(predefined, vars.rhino);
|
||||
}
|
||||
|
|
@ -1626,6 +1749,10 @@ var JSHINT = (function () {
|
|||
combine(predefined, vars.nonstandard);
|
||||
}
|
||||
|
||||
if (state.option.jasmine) {
|
||||
combine(predefined, vars.jasmine);
|
||||
}
|
||||
|
||||
if (state.option.jquery) {
|
||||
combine(predefined, vars.jquery);
|
||||
}
|
||||
|
|
@ -2208,11 +2335,13 @@ var JSHINT = (function () {
|
|||
if (state.tokens.next.id === "(end)")
|
||||
error("E006", state.tokens.curr);
|
||||
|
||||
if (state.option.asi &&
|
||||
(state.tokens.curr.id === "[" ||
|
||||
state.tokens.curr.id === "(" ||
|
||||
state.tokens.curr.id === "/") &&
|
||||
state.tokens.prev.line < state.tokens.curr.line)
|
||||
var isDangerous =
|
||||
state.option.asi &&
|
||||
state.tokens.prev.line < state.tokens.curr.line &&
|
||||
_.contains(["]", ")"], state.tokens.prev.id) &&
|
||||
_.contains(["[", "("], state.tokens.curr.id);
|
||||
|
||||
if (isDangerous)
|
||||
warning("W014", state.tokens.curr, state.tokens.curr.id);
|
||||
|
||||
advance();
|
||||
|
|
@ -2792,6 +2921,21 @@ var JSHINT = (function () {
|
|||
}
|
||||
}
|
||||
|
||||
function parseFinalSemicolon() {
|
||||
if (state.tokens.next.id !== ";") {
|
||||
if (!state.option.asi) {
|
||||
// If this is the last statement in a block that ends on
|
||||
// the same line *and* option lastsemic is on, ignore the warning.
|
||||
// Otherwise, complain about missing semicolon.
|
||||
if (!state.option.lastsemic || state.tokens.next.id !== "}" ||
|
||||
state.tokens.next.line !== state.tokens.curr.line) {
|
||||
warningAt("W033", state.tokens.curr.line, state.tokens.curr.character);
|
||||
}
|
||||
}
|
||||
} else {
|
||||
advance(";");
|
||||
}
|
||||
}
|
||||
|
||||
function statement() {
|
||||
var values;
|
||||
|
|
@ -2814,6 +2958,23 @@ var JSHINT = (function () {
|
|||
res = false;
|
||||
}
|
||||
|
||||
// detect a module import declaration
|
||||
if (t.value === "module" && t.type === "(identifier)") {
|
||||
if (peek().type === "(identifier)") {
|
||||
if (!state.option.inESNext()) {
|
||||
warning("W119", state.tokens.curr, "module");
|
||||
}
|
||||
|
||||
advance("module");
|
||||
var name = identifier();
|
||||
addlabel(name, { type: "unused", token: state.tokens.curr });
|
||||
advance("from");
|
||||
advance("(string)");
|
||||
parseFinalSemicolon();
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
// detect a destructuring assignment
|
||||
if (_.has(["[", "{"], t.value)) {
|
||||
if (lookupBlockType().isDestAssign) {
|
||||
|
|
@ -2879,21 +3040,9 @@ var JSHINT = (function () {
|
|||
} else if (state.option.nonew && r && r.left && r.id === "(" && r.left.id === "new") {
|
||||
warning("W031", t);
|
||||
}
|
||||
parseFinalSemicolon();
|
||||
}
|
||||
|
||||
if (state.tokens.next.id !== ";") {
|
||||
if (!state.option.asi) {
|
||||
// If this is the last statement in a block that ends on
|
||||
// the same line *and* option lastsemic is on, ignore the warning.
|
||||
// Otherwise, complain about missing semicolon.
|
||||
if (!state.option.lastsemic || state.tokens.next.id !== "}" ||
|
||||
state.tokens.next.line !== state.tokens.curr.line) {
|
||||
warningAt("W033", state.tokens.curr.line, state.tokens.curr.character);
|
||||
}
|
||||
}
|
||||
} else {
|
||||
advance(";");
|
||||
}
|
||||
}
|
||||
|
||||
// Restore the indentation.
|
||||
|
||||
|
|
@ -5432,7 +5581,6 @@ var JSHINT = (function () {
|
|||
FutureReservedWord("static", { es5: true, strictOnly: true });
|
||||
FutureReservedWord("super", { es5: true });
|
||||
FutureReservedWord("synchronized");
|
||||
FutureReservedWord("throws");
|
||||
FutureReservedWord("transient");
|
||||
FutureReservedWord("volatile");
|
||||
|
||||
|
|
@ -8150,7 +8298,7 @@ exports.starSlash = /\*\//;
|
|||
exports.identifier = /^([a-zA-Z_$][a-zA-Z0-9_$]*)$/;
|
||||
|
||||
// JavaScript URL (jx)
|
||||
exports.javascriptURL = /^(?:javascript|jscript|ecmascript|vbscript|mocha|livescript)\s*:/i;
|
||||
exports.javascriptURL = /^(?:javascript|jscript|ecmascript|vbscript|livescript)\s*:/i;
|
||||
|
||||
// Catches /* falls through */ comments (ft)
|
||||
exports.fallsThrough = /^\s*\/\*\s*falls?\sthrough\s*\*\/\s*$/;
|
||||
|
|
@ -8323,7 +8471,7 @@ exports.register = function (linter) {
|
|||
// Warn about script URLs.
|
||||
|
||||
linter.on("String", function style_scanJavaScriptURLs(data) {
|
||||
var re = /^(?:javascript|jscript|ecmascript|vbscript|mocha|livescript)\s*:/i;
|
||||
var re = /^(?:javascript|jscript|ecmascript|vbscript|livescript)\s*:/i;
|
||||
|
||||
if (linter.getOption("scripturl")) {
|
||||
return;
|
||||
|
|
@ -8756,6 +8904,27 @@ exports.phantom = {
|
|||
exports : true // v1.7+
|
||||
};
|
||||
|
||||
exports.qunit = {
|
||||
asyncTest : false,
|
||||
deepEqual : false,
|
||||
equal : false,
|
||||
expect : false,
|
||||
module : false,
|
||||
notDeepEqual : false,
|
||||
notEqual : false,
|
||||
notPropEqual : false,
|
||||
notStrictEqual : false,
|
||||
ok : false,
|
||||
propEqual : false,
|
||||
QUnit : false,
|
||||
raises : false,
|
||||
start : false,
|
||||
stop : false,
|
||||
strictEqual : false,
|
||||
test : false,
|
||||
"throws" : false
|
||||
};
|
||||
|
||||
exports.rhino = {
|
||||
defineClass : false,
|
||||
deserialize : false,
|
||||
|
|
@ -8875,7 +9044,7 @@ exports.mootools = {
|
|||
Group : false,
|
||||
Hash : false,
|
||||
HtmlTable : false,
|
||||
Iframe : false,
|
||||
IFrame : false,
|
||||
IframeShim : false,
|
||||
InputValidator: false,
|
||||
instanceOf : false,
|
||||
|
|
@ -8962,6 +9131,23 @@ exports.mocha = {
|
|||
teardown : false
|
||||
};
|
||||
|
||||
exports.jasmine = {
|
||||
jasmine : false,
|
||||
describe : false,
|
||||
it : false,
|
||||
xit : false,
|
||||
beforeEach : false,
|
||||
afterEach : false,
|
||||
setFixtures : false,
|
||||
loadFixtures: false,
|
||||
spyOn : false,
|
||||
expect : false,
|
||||
// Jasmine 1.3
|
||||
runs : false,
|
||||
waitsFor : false,
|
||||
waits : false
|
||||
};
|
||||
|
||||
},
|
||||
{}],
|
||||
10:[function(_dereq_,module,exports){
|
||||
|
|
|
|||
|
|
@ -85,7 +85,7 @@ var deps = {
|
|||
jshint: {
|
||||
path: "mode/javascript/jshint.js",
|
||||
browserify: {
|
||||
npmModule: "git+https://github.com/nightwing/jshint.git#master",
|
||||
npmModule: "git+https://github.com/ajaxorg/jshint.git#master",
|
||||
path: "jshint/src/jshint.js",
|
||||
exports: "jshint"
|
||||
},
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue