pinclub/pinclub

Function runInContext has 2465 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.compat.js has 2728 lines of code (exceeds 250 allowed). Consider refactoring.

Open

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

Function baseIsEqual has 113 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 iteratorTemplate has 89 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    var iteratorTemplate = function (obj) {

      var __p = 'var index, iterable = ' +
        (obj.firstArg) +
        ', result = ' +

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 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 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 baseCreateCallback has 45 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 intersection has 44 lines of code (exceeds 25 allowed). Consider refactoring.

Open

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

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)) {

Consider simplifying this complex logical expression.

Open

      if (!(value && toString.call(value) == objectClass) ||
        (ctor = value.constructor, isFunction(ctor) && !(ctor instanceof ctor)) ||
        (!support.argsClass && isArguments(value)) ||
        (!support.nodeClass && isNode(value))) {
        return false;

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 30 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 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 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 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

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

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) {

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 (!support.argsClass) {
      isArguments = function (value) {
        return value && typeof value == 'object' && typeof value.length == 'number' &&
          hasOwnProperty.call(value, 'callee') && !propertyIsEnumerable.call(value, 'callee') || false;
      };

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 ||
        (support.argsClass ? className == argsClass : isArguments(value))) ||
        (className == objectClass && typeof length == 'number' && isFunction(value.splice))) {
        return !length;
      }

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

Open

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

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

Open

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

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];

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 result;

Avoid too many return statements within this function.

Open

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

Avoid too many return statements within this function.

Open

          return stackB[length] == b;

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 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 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 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 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

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

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 (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 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 isString(value) {
      return typeof value == 'string' ||
        value && typeof value == 'object' && toString.call(value) == stringClass || false;
    }

• 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

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

    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 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

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

• Read up
  Read up

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

Open

      var index = -1,
        length = collection ? collection.length : 0,
        result = Array(typeof length == 'number' ? length : 0);

• Read up
  Read up

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

Open

      var index = -1,
        length = collection ? collection.length : 0,
        result = Array(typeof length == 'number' ? length : 0);

• Read up
  Read up