adobe/brackets

File immutable.js has 3950 lines of code (exceeds 250 allowed). Consider refactoring.

Open

/**
 * Copyright (c) 2014-present, Facebook, Inc.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.

Function setListBounds has 95 lines of code (exceeds 25 allowed). Consider refactoring.

Open

  function setListBounds(list, begin, end) {
    // Sanitize begin & end using this shorthand for ToInt32(argument)
    // http://www.ecma-international.org/ecma-262/6.0/#sec-toint32
    if (begin !== undefined) {
      begin = begin | 0;

Function sliceFactory has 78 lines of code (exceeds 25 allowed). Consider refactoring.

Open

  function sliceFactory(iterable, begin, end, useKeys) {
    var originalSize = iterable.size;

    // Sanitize begin & end using this shorthand for ToInt32(argument)
    // http://www.ecma-international.org/ecma-262/6.0/#sec-toint32

Function iterateList has 52 lines of code (exceeds 25 allowed). Consider refactoring.

Open

  function iterateList(list, reverse) {
    var left = list._origin;
    var right = list._capacity;
    var tailPos = getTailOffset(right);
    var tail = list._tail;

Consider simplifying this complex logical expression.

Open

    if (
      !isIterable(b) ||
      a.size !== undefined && b.size !== undefined && a.size !== b.size ||
      a.__hash !== undefined && b.__hash !== undefined && a.__hash !== b.__hash ||
      isKeyed(a) !== isKeyed(b) ||

Function hashJSObj has 48 lines of code (exceeds 25 allowed). Consider refactoring.

Open

  function hashJSObj(obj) {
    var hash;
    if (usingWeakMap) {
      hash = weakMap.get(obj);
      if (hash !== undefined) {

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

Open

  function deepEqual(a, b) {
    if (a === b) {
      return true;
    }

Function skipWhileFactory has 45 lines of code (exceeds 25 allowed). Consider refactoring.

Open

  function skipWhileFactory(iterable, predicate, context, useKeys) {
    var skipSequence = makeSequence(iterable);
    skipSequence.__iterateUncached = function (fn, reverse) {var this$0 = this;
      if (reverse) {
        return this.cacheResult().__iterate(fn, reverse);

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

Open

    HashCollisionNode.prototype.update = function(ownerID, shift, keyHash, key, value, didChangeSize, didAlter) {
      if (keyHash === undefined) {
        keyHash = hash(key);
      }

Function flattenFactory has 43 lines of code (exceeds 25 allowed). Consider refactoring.

Open

  function flattenFactory(iterable, depth, useKeys) {
    var flatSequence = makeSequence(iterable);
    flatSequence.__iterateUncached = function(fn, reverse) {
      var iterations = 0;
      var stopped = false;

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

Open

  function concatFactory(iterable, values) {
    var isKeyedIterable = isKeyed(iterable);
    var iters = [iterable].concat(values).map(function(v ) {
      if (!isIterable(v)) {
        v = isKeyedIterable ?

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

Open

  function filterFactory(iterable, predicate, context, useKeys) {
    var filterSequence = makeSequence(iterable);
    if (useKeys) {
      filterSequence.has = function(key ) {
        var v = iterable.get(key, NOT_SET);

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

Open

  function updateOrderedMap(omap, k, v) {
    var map = omap._map;
    var list = omap._list;
    var i = map.get(k);
    var has = i !== undefined;

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

Open

  function hash(o) {
    if (o === false || o === null || o === undefined) {
      return 0;
    }
    if (typeof o.valueOf === 'function') {

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

Open

    BitmapIndexedNode.prototype.update = function(ownerID, shift, keyHash, key, value, didChangeSize, didAlter) {
      if (keyHash === undefined) {
        keyHash = hash(key);
      }
      var keyHashFrag = (shift === 0 ? keyHash : keyHash >>> shift) & MASK;

Function takeWhileFactory has 37 lines of code (exceeds 25 allowed). Consider refactoring.

Open

  function takeWhileFactory(iterable, predicate, context) {
    var takeSequence = makeSequence(iterable);
    takeSequence.__iterateUncached = function(fn, reverse) {var this$0 = this;
      if (reverse) {
        return this.cacheResult().__iterate(fn, reverse);

Function update has 36 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    ArrayMapNode.prototype.update = function(ownerID, shift, keyHash, key, value, didChangeSize, didAlter) {
      var removed = value === NOT_SET;

      var entries = this.entries;
      var idx = 0;

Function zipWithFactory has 36 lines of code (exceeds 25 allowed). Consider refactoring.

Open

  function zipWithFactory(keyIter, zipper, iters) {
    var zipSequence = makeSequence(keyIter);
    zipSequence.size = new ArraySeq(iters).map(function(i ) {return i.size}).min();
    // Note: this a generic base implementation of __iterate in terms of
    // __iterator which may be more generically useful in the future.

Function flipFactory has 34 lines of code (exceeds 25 allowed). Consider refactoring.

Open

  function flipFactory(iterable) {
    var flipSequence = makeSequence(iterable);
    flipSequence._iter = iterable;
    flipSequence.size = iterable.size;
    flipSequence.flip = function()  {return iterable};

Function mapFactory has 33 lines of code (exceeds 25 allowed). Consider refactoring.

Open

  function mapFactory(iterable, mapper, context) {
    var mappedSequence = makeSequence(iterable);
    mappedSequence.size = iterable.size;
    mappedSequence.has = function(key ) {return iterable.has(key)};
    mappedSequence.get = function(key, notSetValue)  {

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

Open

    MapIterator.prototype.next = function() {
      var type = this._type;
      var stack = this._stack;
      while (stack) {
        var node = stack.node;

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

Open

  function updateList(list, index, value) {
    index = wrapIndex(list, index);

    if (index !== index) {
      return list;

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

Open

    HashArrayMapNode.prototype.update = function(ownerID, shift, keyHash, key, value, didChangeSize, didAlter) {
      if (keyHash === undefined) {
        keyHash = hash(key);
      }
      var idx = (shift === 0 ? keyHash : keyHash >>> shift) & MASK;

Function removeBefore has 29 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    VNode.prototype.removeBefore = function(ownerID, level, index) {
      if (index === level ? 1 << level : 0 || this.array.length === 0) {
        return this;
      }
      var originIndex = (index >>> level) & MASK;

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

Open

    skipSequence.__iteratorUncached = function(type, reverse) {var this$0 = this;
      if (reverse) {
        return this.cacheResult().__iterator(type, reverse);
      }
      var iterator = iterable.__iterator(ITERATE_ENTRIES, reverse);

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

Open

  function interposeFactory(iterable, separator) {
    var interposedSequence = makeSequence(iterable);
    interposedSequence.size = iterable.size && iterable.size * 2 -1;
    interposedSequence.__iterateUncached = function(fn, reverse) {var this$0 = this;
      var iterations = 0;

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

Open

  function updateVNode(node, ownerID, level, index, value, didAlter) {
    var idx = (index >>> level) & MASK;
    var nodeHas = node && idx < node.array.length;
    if (!nodeHas && value === undefined) {
      return node;

Function updateNode has 8 arguments (exceeds 4 allowed). Consider refactoring.

Open

  function updateNode(node, ownerID, shift, keyHash, key, value, didChangeSize, didAlter) {

Function makeList has 7 arguments (exceeds 4 allowed). Consider refactoring.

Open

  function makeList(origin, capacity, level, root, tail, ownerID, hash) {

Function update has 7 arguments (exceeds 4 allowed). Consider refactoring.

Open

    BitmapIndexedNode.prototype.update = function(ownerID, shift, keyHash, key, value, didChangeSize, didAlter) {

Function update has 7 arguments (exceeds 4 allowed). Consider refactoring.

Open

    HashCollisionNode.prototype.update = function(ownerID, shift, keyHash, key, value, didChangeSize, didAlter) {

Function update has 7 arguments (exceeds 4 allowed). Consider refactoring.

Open

    ValueNode.prototype.update = function(ownerID, shift, keyHash, key, value, didChangeSize, didAlter) {

Function update has 7 arguments (exceeds 4 allowed). Consider refactoring.

Open

    ArrayMapNode.prototype.update = function(ownerID, shift, keyHash, key, value, didChangeSize, didAlter) {

Function update has 7 arguments (exceeds 4 allowed). Consider refactoring.

Open

    HashArrayMapNode.prototype.update = function(ownerID, shift, keyHash, key, value, didChangeSize, didAlter) {

Avoid deeply nested control flow statements.

Open

            if (subNode) {
              if (subNode.entry) {
                return mapIteratorValue(type, subNode.entry);
              }
              stack = this._stack = mapIteratorFrame(subNode, stack);

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

Open

  function updateVNode(node, ownerID, level, index, value, didAlter) {

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

Open

  function mergeIntoNode(node, ownerID, shift, keyHash, entry) {

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

Open

  function expandNodes(ownerID, nodes, bitmap, including, node) {

Avoid too many return statements within this function.

Open

      return true;

Avoid too many return statements within this function.

Open

    return hash;

Avoid too many return statements within this function.

Open

        return this;

Avoid too many return statements within this function.

Open

      return mergeIntoNode(this, ownerID, shift, hash(key), [key, value]);

Avoid too many return statements within this function.

Open

      return o.hashCode();

Avoid too many return statements within this function.

Open

      return new ArrayMapNode(ownerID, newEntries);

Avoid too many return statements within this function.

Open

      return empty.withMutations(function(list ) {
        list.setSize(size);
        iter.forEach(function(v, i)  {return list.set(i, v)});
      });

Avoid too many return statements within this function.

Open

      return editable;

Avoid too many return statements within this function.

Open

    return false;

Avoid too many return statements within this function.

Open

    return newNode;

Avoid too many return statements within this function.

Open

      return hashString(o.toString());

Avoid too many return statements within this function.

Open

        return this;

Avoid too many return statements within this function.

Open

      return o.length > STRING_HASH_CACHE_MIN_STRLEN ? cachedHashString(o) : hashString(o);

Avoid too many return statements within this function.

Open

    return makeList(list._origin, list._capacity, list._level, newRoot, newTail);

Avoid too many return statements within this function.

Open

    return allEqual && a.size === bSize;

Avoid too many return statements within this function.

Open

      return new HashCollisionNode(ownerID, this.keyHash, newEntries);

Avoid too many return statements within this function.

Open

      return smi(h);

Avoid too many return statements within this function.

Open

      return new BitmapIndexedNode(ownerID, newBitmap, newNodes);

Avoid too many return statements within this function.

Open

      return new HashArrayMapNode(ownerID, newCount, newNodes);

Avoid too many return statements within this function.

Open

      return hashJSObj(o);

Avoid too many return statements within this function.

Open

        return newNode;

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

Open

    Map.prototype.mergeDeepIn = function(keyPath) {var iters = SLICE$0.call(arguments, 1);
      return this.updateIn(
        keyPath,
        emptyMap(),
        function(m ) {return typeof m.mergeDeep === 'function' ?

• Read up
  Read up

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

Open

    Map.prototype.mergeIn = function(keyPath) {var iters = SLICE$0.call(arguments, 1);
      return this.updateIn(
        keyPath,
        emptyMap(),
        function(m ) {return typeof m.merge === 'function' ?

• Read up
  Read up

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

Open

    HashCollisionNode.prototype.get = function(shift, keyHash, key, notSetValue) {
      var entries = this.entries;
      for (var ii = 0, len = entries.length; ii < len; ii++) {
        if (is(key, entries[ii][0])) {
          return entries[ii][1];

• Read up
  Read up

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

Open

    ArrayMapNode.prototype.get = function(shift, keyHash, key, notSetValue) {
      var entries = this.entries;
      for (var ii = 0, len = entries.length; ii < len; ii++) {
        if (is(key, entries[ii][0])) {
          return entries[ii][1];

• Read up
  Read up

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

Open

    Stack.prototype.__ensureOwner = function(ownerID) {
      if (ownerID === this.__ownerID) {
        return this;
      }
      if (!ownerID) {

• Read up
  Read up

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

Open

    Map.prototype.__ensureOwner = function(ownerID) {
      if (ownerID === this.__ownerID) {
        return this;
      }
      if (!ownerID) {

• Read up
  Read up

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

Open

      if (exists) {
        if (removed) {
          idx === len - 1 ? newEntries.pop() : (newEntries[idx] = newEntries.pop());
        } else {
          newEntries[idx] = [key, value];

• Read up
  Read up

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

Open

      if (exists) {
        if (removed) {
          idx === len - 1 ? newEntries.pop() : (newEntries[idx] = newEntries.pop());
        } else {
          newEntries[idx] = [key, value];

• Read up
  Read up

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

Open

  function makeMap(size, root, ownerID, hash) {
    var map = Object.create(MapPrototype);
    map.size = size;
    map._root = root;
    map.__ownerID = ownerID;

• Read up
  Read up

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

Open

  function makeStack(size, head, ownerID, hash) {
    var map = Object.create(StackPrototype);
    map.size = size;
    map._head = head;
    map.__ownerID = ownerID;

• Read up
  Read up

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

Open

    Record.prototype.__iterate = function(fn, reverse) {var this$0 = this;
      return KeyedIterable(this._defaultValues).map(function(_, k)  {return this$0.get(k)}).__iterate(fn, reverse);
    };

• Read up
  Read up

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

Open

    Record.prototype.__iterator = function(type, reverse) {var this$0 = this;
      return KeyedIterable(this._defaultValues).map(function(_, k)  {return this$0.get(k)}).__iterator(type, reverse);
    };

• Read up
  Read up

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

Open

  function makeSet(map, ownerID) {
    var set = Object.create(SetPrototype);
    set.size = map ? map.size : 0;
    set._map = map;
    set.__ownerID = ownerID;

• Read up
  Read up

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

Open

        isMap(value) && !isOrdered(value) ? value :
        emptyMap().withMutations(function(map ) {
          var iter = KeyedIterable(value);
          assertNotInfinite(iter.size);
          iter.forEach(function(v, k)  {return map.set(k, v)});

• Read up
  Read up

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

Open

        isOrderedMap(value) ? value :
        emptyOrderedMap().withMutations(function(map ) {
          var iter = KeyedIterable(value);
          assertNotInfinite(iter.size);
          iter.forEach(function(v, k)  {return map.set(k, v)});

• Read up
  Read up

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

Open

  function makeOrderedSet(map, ownerID) {
    var set = Object.create(OrderedSetPrototype);
    set.size = map ? map.size : 0;
    set._map = map;
    set.__ownerID = ownerID;

• Read up
  Read up

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

Open

    toJSON: function() {
      return this.toSeq().map(
        function(value ) {return value && typeof value.toJSON === 'function' ? value.toJSON() : value}
      ).__toJS();
    },

• Read up
  Read up

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

Open

    toJS: function() {
      return this.toSeq().map(
        function(value ) {return value && typeof value.toJS === 'function' ? value.toJS() : value}
      ).__toJS();
    },

• Read up
  Read up

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

Open

        isOrderedSet(value) ? value :
        emptyOrderedSet().withMutations(function(set ) {
          var iter = SetIterable(value);
          assertNotInfinite(iter.size);
          iter.forEach(function(v ) {return set.add(v)});

• Read up
  Read up

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

Open

        isSet(value) && !isOrdered(value) ? value :
        emptySet().withMutations(function(set ) {
          var iter = SetIterable(value);
          assertNotInfinite(iter.size);
          iter.forEach(function(v ) {return set.add(v)});

• Read up
  Read up

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

Open

      if (this.__ownerID) {
        this.size = newSize;
        this._head = head;
        this.__hash = undefined;
        this.__altered = true;

• Read up
  Read up

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

Open

      if (this.__ownerID) {
        this.size = newSize;
        this._head = head;
        this.__hash = undefined;
        this.__altered = true;

• Read up
  Read up

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

Open

      if (this.__ownerID) {
        this.size = newSize;
        this._head = head;
        this.__hash = undefined;
        this.__altered = true;

• Read up
  Read up

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

Open

    if (list.__ownerID) {
      list._root = newRoot;
      list._tail = newTail;
      list.__hash = undefined;
      list.__altered = true;

• Read up
  Read up

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

Open

    if (map.__ownerID) {
      map.size = newSize;
      map._root = newRoot;
      map.__hash = undefined;
      map.__altered = true;

• Read up
  Read up

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

Open

    Map.prototype.mergeDeepWith = function(merger) {var iters = SLICE$0.call(arguments, 1);
      return mergeIntoMapWith(this, deepMergerWith(merger), iters);
    };

• Read up
  Read up

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

Open

    List.prototype.mergeDeepWith = function(merger) {var iters = SLICE$0.call(arguments, 1);
      return mergeIntoListWith(this, deepMergerWith(merger), iters);
    };

• Read up
  Read up

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

Open

      for (var len = entries.length; idx < len; idx++) {
        if (is(key, entries[idx][0])) {
          break;
        }
      }

• Read up
  Read up

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

Open

      for (var len = entries.length; idx < len; idx++) {
        if (is(key, entries[idx][0])) {
          break;
        }
      }

• Read up
  Read up

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

Open

      while (!(step = iterator.next()).done) {
        if (fn(step.value, iterations++, this) === false) {
          break;
        }
      }

• Read up
  Read up

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

Open

    takeLast: function(amount) {
      return reify(this, this.toSeq().reverse().take(amount).reverse());
    },

• Read up
  Read up

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

Open

        while (!(step = iterator.next()).done) {
          if (fn(step.value, iterations++, this) === false) {
            break;
          }
        }

• Read up
  Read up

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

Open

    skipLast: function(amount) {
      return reify(this, this.toSeq().reverse().skip(amount).reverse());
    },

• Read up
  Read up

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

Open

    List.prototype.mergeWith = function(merger) {var iters = SLICE$0.call(arguments, 1);
      return mergeIntoListWith(this, merger, iters);
    };

• Read up
  Read up

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

Open

    Map.prototype.mergeWith = function(merger) {var iters = SLICE$0.call(arguments, 1);
      return mergeIntoMapWith(this, merger, iters);
    };

• Read up
  Read up

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

Open

    if (isPlainObj(json)) {
      return converter.call(parentJSON, key, KeyedSeq(json).map(function(v, k)  {return fromJSWith(converter, v, k, json)}));
    }

• Read up
  Read up

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

Open

    if (Array.isArray(json)) {
      return converter.call(parentJSON, key, IndexedSeq(json).map(function(v, k)  {return fromJSWith(converter, v, k, json)}));
    }

• Read up
  Read up