kuasha/cosmos

Function runInContext has 2277 lines of code (exceeds 25 allowed). Consider refactoring.

Open

  function runInContext(context) {
    // Avoid issues with some ES3 environments that attempt to use values, named
    // after built-in constructors like `Object`, for the creation of literals.
    // ES5 clears this up by stating that literals must use built-in constructors.
    // See http://es5.github.io/#x11.1.5.

File lodash.js has 2517 lines of code (exceeds 250 allowed). Consider refactoring.

Open

/**
 * @license
 * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/>
 * Build: `lodash modern -o ./dist/lodash.js`
 * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/>

Function baseIsEqual has 116 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    function baseIsEqual(a, b, callback, isWhere, stackA, stackB) {
      // used to indicate that when comparing objects, `a` has at least the properties of `b`
      if (callback) {
        var result = callback(a, b);
        if (typeof result != 'undefined') {

Function debounce has 93 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    function debounce(func, wait, options) {
      var args,
          maxTimeoutId,
          result,
          stamp,

Function baseClone has 65 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    function baseClone(value, isDeep, callback, stackA, stackB) {
      if (callback) {
        var result = callback(value);
        if (typeof result != 'undefined') {
          return result;

Function template has 63 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    function template(text, data, options) {
      // based on John Resig's `tmpl` implementation
      // http://ejohn.org/blog/javascript-micro-templating/
      // and Laura Doktorova's doT.js
      // https://github.com/olado/doT

Function baseMerge has 46 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    function baseMerge(object, source, callback, stackA, stackB) {
      (isArray(source) ? forEach : forOwn)(source, function(source, key) {
        var found,
            isArr,
            result = source,

Function createWrapper has 46 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    function createWrapper(func, bitmask, partialArgs, partialRightArgs, thisArg, arity) {
      var isBind = bitmask & 1,
          isBindKey = bitmask & 2,
          isCurry = bitmask & 4,
          isCurryBound = bitmask & 8,

Function intersection has 44 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    function intersection() {
      var args = [],
          argsIndex = -1,
          argsLength = arguments.length,
          caches = getArray(),

Function baseCreateCallback has 41 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    function baseCreateCallback(func, thisArg, argCount) {
      if (typeof func != 'function') {
        return identity;
      }
      // exit early for no `thisArg` or already bound by `Function#bind`

Function baseCreateWrapper has 40 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    function baseCreateWrapper(bindData) {
      var func = bindData[0],
          bitmask = bindData[1],
          partialArgs = bindData[2],
          partialRightArgs = bindData[3],

Function mixin has 38 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    function mixin(object, source, options) {
      var chain = true,
          methodNames = source && functions(source);

      if (!source || (!options && !methodNames.length)) {

Function baseUniq has 31 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    function baseUniq(array, isSorted, callback) {
      var index = -1,
          indexOf = getIndexOf(),
          length = array ? array.length : 0,
          result = [];

Function sortBy has 28 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    function sortBy(collection, callback, thisArg) {
      var index = -1,
          isArr = isArray(callback),
          length = collection ? collection.length : 0,
          result = Array(typeof length == 'number' ? length : 0);

Function max has 27 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    function max(collection, callback, thisArg) {
      var computed = -Infinity,
          result = computed;

      // allows working with functions like `_.map` without using

Function random has 27 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    function random(min, max, floating) {
      var noMin = min == null,
          noMax = max == null;

      if (floating == null) {

Function min has 27 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    function min(collection, callback, thisArg) {
      var computed = Infinity,
          result = computed;

      // allows working with functions like `_.map` without using

Function createCallback has 26 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    function createCallback(func, thisArg, argCount) {
      var type = typeof func;
      if (func == null || type == 'function') {
        return baseCreateCallback(func, thisArg, argCount);
      }

Consider simplifying this complex logical expression.

Open

        if (ctorA != ctorB &&
              !(isFunction(ctorA) && ctorA instanceof ctorA && isFunction(ctorB) && ctorB instanceof ctorB) &&
              ('constructor' in a && 'constructor' in b)
            ) {
          return false;

Avoid deeply nested control flow statements.

Open

            } else if (!(result = baseIsEqual(a[size], value, callback, isWhere, stackA, stackB))) {
              break;
            }

Function baseIsEqual has 6 arguments (exceeds 4 allowed). Consider refactoring.

Open

    function baseIsEqual(a, b, callback, isWhere, stackA, stackB) {

Avoid deeply nested control flow statements.

Open

              while (index--) {
                if ((result = baseIsEqual(a[index], value, callback, isWhere, stackA, stackB))) {
                  break;
                }
              }

Function createWrapper has 6 arguments (exceeds 4 allowed). Consider refactoring.

Open

    function createWrapper(func, bitmask, partialArgs, partialRightArgs, thisArg, arity) {

Consider simplifying this complex logical expression.

Open

    if (first && typeof first == 'object' &&
        mid && typeof mid == 'object' && last && typeof last == 'object') {
      return false;
    }

Consider simplifying this complex logical expression.

Open

      if ((className == arrayClass || className == stringClass || className == argsClass ) ||
          (className == objectClass && typeof length == 'number' && isFunction(value.splice))) {
        return !length;
      }

Function baseMerge has 5 arguments (exceeds 4 allowed). Consider refactoring.

Open

    function baseMerge(object, source, callback, stackA, stackB) {

Function baseClone has 5 arguments (exceeds 4 allowed). Consider refactoring.

Open

    function baseClone(value, isDeep, callback, stackA, stackB) {

Avoid too many return statements within this function.

Open

        return result;

Avoid too many return statements within this function.

Open

          return false;

Avoid too many return statements within this function.

Open

      return result;

Avoid too many return statements within this function.

Open

        return false;

Avoid too many return statements within this function.

Open

      return result;

Avoid too many return statements within this function.

Open

          return false;

Avoid too many return statements within this function.

Open

          return stackB[length] == b;

Avoid too many return statements within this function.

Open

            return stackB[length];

Avoid too many return statements within this function.

Open

          return baseIsEqual(aWrapped ? a.__wrapped__ : a, bWrapped ? b.__wrapped__ : b, callback, isWhere, stackA, stackB);

Similar blocks of code found in 2 locations. Consider refactoring.

Open

      if (callback == null && isArray(collection)) {
        var index = -1,
            length = collection.length;

        while (++index < length) {

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

      if (callback == null && isArray(collection)) {
        var index = -1,
            length = collection.length;

        while (++index < length) {

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

      if (argsLength > 3 && typeof args[argsLength - 2] == 'function') {
        var callback = baseCreateCallback(args[--argsLength - 1], args[argsLength--], 2);
      } else if (argsLength > 2 && typeof args[argsLength - 1] == 'function') {
        callback = args[--argsLength];
      }

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

      if (length > 3 && typeof args[length - 2] == 'function') {
        var callback = baseCreateCallback(args[--length - 1], args[length--], 2);
      } else if (length > 2 && typeof args[length - 1] == 'function') {
        callback = args[--length];
      }

• Read up
  Read up

Similar blocks of code found in 3 locations. Consider refactoring.

Open

    function findLast(collection, callback, thisArg) {
      var result;
      callback = lodash.createCallback(callback, thisArg, 3);
      forEachRight(collection, function(value, index, collection) {
        if (callback(value, index, collection)) {

• Read up
  Read up

Similar blocks of code found in 3 locations. Consider refactoring.

Open

    function findLastKey(object, callback, thisArg) {
      var result;
      callback = lodash.createCallback(callback, thisArg, 3);
      forOwnRight(object, function(value, key, object) {
        if (callback(value, key, object)) {

• Read up
  Read up

Similar blocks of code found in 3 locations. Consider refactoring.

Open

    function findKey(object, callback, thisArg) {
      var result;
      callback = lodash.createCallback(callback, thisArg, 3);
      forOwn(object, function(value, key, object) {
        if (callback(value, key, object)) {

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

      if (typeof isShallow != 'boolean' && isShallow != null) {
        thisArg = callback;
        callback = (typeof isShallow != 'function' && thisArg && thisArg[isShallow] === array) ? null : isShallow;
        isShallow = false;
      }

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

      if (typeof isSorted != 'boolean' && isSorted != null) {
        thisArg = callback;
        callback = (typeof isSorted != 'function' && thisArg && thisArg[isSorted] === array) ? null : isSorted;
        isSorted = false;
      }

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

          if (isCalled) {
            lastCalled = now();
            result = func.apply(thisArg, args);
            if (!timeoutId && !maxTimeoutId) {
              args = thisArg = null;

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

        if (trailing || (maxWait !== wait)) {
          lastCalled = now();
          result = func.apply(thisArg, args);
          if (!timeoutId && !maxTimeoutId) {
            args = thisArg = null;

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

      if (typeof callback != 'number' && callback != null) {
        var index = length;
        callback = lodash.createCallback(callback, thisArg, 3);
        while (index-- && callback(array[index], index, array)) {
          n++;

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

      if (typeof callback != 'number' && callback != null) {
        var index = length;
        callback = lodash.createCallback(callback, thisArg, 3);
        while (index-- && callback(array[index], index, array)) {
          n++;

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

    function isString(value) {
      return typeof value == 'string' ||
        value && typeof value == 'object' && toString.call(value) == stringClass || false;
    }

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

    function isNumber(value) {
      return typeof value == 'number' ||
        value && typeof value == 'object' && toString.call(value) == numberClass || false;
    }

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

    function bind(func, thisArg) {
      return arguments.length > 2
        ? createWrapper(func, 17, slice(arguments, 2), null, thisArg)
        : createWrapper(func, 1, null, null, thisArg);
    }

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

    function bindKey(object, key) {
      return arguments.length > 2
        ? createWrapper(key, 19, slice(arguments, 2), null, object)
        : createWrapper(key, 3, null, null, object);
    }

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

    var isArray = nativeIsArray || function(value) {
      return value && typeof value == 'object' && typeof value.length == 'number' &&
        toString.call(value) == arrayClass || false;
    };

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

    function isArguments(value) {
      return value && typeof value == 'object' && typeof value.length == 'number' &&
        toString.call(value) == argsClass || false;
    }

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

    function isDate(value) {
      return value && typeof value == 'object' && toString.call(value) == dateClass || false;
    }

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

    function isRegExp(value) {
      return value && typeof value == 'object' && toString.call(value) == regexpClass || false;
    }

• Read up
  Read up