Code coverage report for 6to5/lib/6to5/generation/node/index.js

Statements: 97.33% (73 / 75)      Branches: 95.24% (40 / 42)      Functions: 100% (12 / 12)      Lines: 96.97% (64 / 66)      Ignored: none     

All files » 6to5/lib/6to5/generation/node/ » index.js
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 1171   1 1 1 1   1 43342 40871   40871 40871 453655   453655 7180 7180 7180       40871     1 125817 125817     1 55096     1 7061 7061 7061   6977 2092     6977 6977   5020 757 757   5020     1 3152     1 3152     1 31830 31830   31830   31351 94   91 449   91     31345     1 31830 31830   31830     31351 31309     42       42         42     1 6 125817     125817 125817 125817 757     125817      
module.exports = Node;
 
var whitespace = require("./whitespace");
var parens     = require("./parentheses");
var t          = require("../../types");
var _          = require("lodash");
 
var find = function (obj, node, parent) {
  if (!obj) return;
  var result;
 
  var types = Object.keys(obj);
  for (var i = 0; i < types.length; i++) {
    var type = types[i];
 
    if (t["is" + type](node)) {
      var fn = obj[type];
      result = fn(node, parent);
      if (result != null) break;
    }
  }
 
  return result;
};
 
function Node(node, parent) {
  this.parent = parent;
  this.node   = node;
}
 
Node.prototype.isUserWhitespacable = function () {
  return t.isUserWhitespacable(this.node);
};
 
Node.prototype.needsWhitespace = function (type) {
  var parent = this.parent;
  var node   = this.node;
  if (!node) return 0;
 
  if (t.isExpressionStatement(node)) {
    node = node.expression;
  }
 
  var lines = find(whitespace[type].nodes, node, parent);
  if (lines) return lines;
 
  _.each(find(whitespace[type].list, node, parent), function (expr) {
    lines = Node.needsWhitespace(expr, node, type);
    if (lines) return false;
  });
  return lines || 0;
};
 
Node.prototype.needsWhitespaceBefore = function () {
  return this.needsWhitespace("before");
};
 
Node.prototype.needsWhitespaceAfter = function () {
  return this.needsWhitespace("after");
};
 
Node.prototype.needsParens = function () {
  var parent = this.parent;
  var node   = this.node;
 
  if (!parent) return false;
 
  if (t.isNewExpression(parent) && parent.callee === node) {
    if (t.isCallExpression(node)) return true;
 
    var hasCall = _.some(node, function (val) {
      return t.isCallExpression(val);
    });
    if (hasCall) return true;
  }
 
  return find(parens, node, parent);
};
 
Node.prototype.needsParensNoLineTerminator = function () {
  var parent = this.parent;
  var node   = this.node;
 
  if (!parent) return false;
 
  // no comments
  if (!node.leadingComments || !node.leadingComments.length) {
    return false;
  }
 
  Iif (t.isYieldExpression(parent) || t.isAwaitExpression(parent)) {
    return true;
  }
 
  Iif (t.isContinueStatement(parent) || t.isBreakStatement(parent) ||
      t.isReturnStatement(parent) || t.isThrowStatement(parent)) {
    return true;
  }
 
  return false;
};
 
_.each(Node.prototype, function (fn, key) {
  Node[key] = function (node, parent) {
    var n = new Node(node, parent);
 
    // Avoid leaking arguments to prevent deoptimization
    var skipCount = 2;
    var args = new Array(arguments.length - skipCount);
    for (var i = 0; i < args.length; i++) {
      args[i] = arguments[i + 2];
    }
 
    return n[key].apply(n, args);
  };
});