exports.getIndentEdges = function(node, opts) {
var operator = _tk.findNext(node.left.endToken, node.operator);
if (_tk.findInBetween(operator, node.right.startToken, _tk.isBr) ||
(opts['AssignmentExpression.' + node.right.type] &&
_tk.findInBetween(operator, node.right.endToken, _tk.isBr))) {
// we only indent if assignment is on next line
return {
startToken: operator,
endToken: node.endToken.type !== 'Punctuator' ?
node.endToken.next : node.endToken
};
}
};
exports.getIndentEdges = function(node) {
if (_tk.findInBetween(node.test.endToken, node.consequent.startToken, _tk.isBr)) {
return {
startToken: node.test.endToken.next,
endToken: node.endToken.next
};
}
if (_tk.findInBetween(node.consequent.endToken, node.alternate.startToken, _tk.isBr)) {
return {
startToken: node.consequent.endToken.next,
endToken: node.endToken.next
};
}
};
node.properties.forEach(function(prop) {
// convert comma-first to comma-last
var comma = _tk.findNext(prop.value.endToken, [',', '}']);
if (_tk.isComma(comma)) {
var br = _tk.findInBetween(prop.value.endToken, comma, _tk.isBr);
if (br) {
_tk.remove(br);
}
_tk.remove(comma);
_tk.after(prop.value.endToken, comma);
}
if (!shouldBeSingleLine) {
_br.limitBefore(prop.key.startToken, 'PropertyName');
_br.limitAfter(prop.key.endToken, 'PropertyName');
_br.limitBefore(prop.value.startToken, 'PropertyValue');
_br.limitAfter(prop.value.endToken, 'PropertyValue');
} else if (prop.key.startToken.prev.value !== '{') {
_ws.limitBefore(prop.key.startToken, 'Property');
}
_ws.limitBefore(prop.key.startToken, 'PropertyName');
_ws.limitAfter(prop.key.endToken, 'PropertyName');
_ws.limitBefore(prop.value.startToken, 'PropertyValue');
_ws.limitAfter(prop.value.endToken, 'PropertyValue');
});
node.properties.forEach(function(prop) {
// we need to grab first/last "executable" token to avoid issues (see #191)
var valueStart = _tk.findNextNonEmpty(_tk.findPrev(prop.value.startToken, ':'));
var eol = _tk.findNext(prop.value.endToken, ['LineBreak', ',', '}']);
var valueEnd = _tk.findPrev(eol, function(token) {
return !_tk.isEmpty(token) && !_tk.isComment(token);
});
// convert comma-first to comma-last
var comma = _tk.findNext(prop.value.endToken, [',', '}']);
if (_tk.isComma(comma)) {
var br = _tk.findInBetween(prop.value.endToken, comma, _tk.isBr);
if (br) {
_tk.remove(br);
}
_tk.remove(comma);
_tk.after(valueEnd, comma);
}
if (!shouldBeSingleLine) {
_br.limitBefore(prop.key.startToken, 'PropertyName');
_br.limitAfter(prop.key.endToken, 'PropertyName');
_br.limitBefore(prop.value.startToken, 'PropertyValue');
_br.limitAfter(prop.value.endToken, 'PropertyValue');
} else if (prop.key.startToken.prev.value !== '{') {
_ws.limitBefore(prop.key.startToken, 'Property');
}
_ws.limitBefore(prop.key.startToken, 'PropertyName');
_ws.limitAfter(prop.key.endToken, 'PropertyName');
_ws.limitBefore(valueStart, 'PropertyValue');
_ws.limitAfter(valueEnd, 'PropertyValue');
});
function isTopChainedMemberExpression(node) {
return node &&
node.type === 'MemberExpression' &&
node.parent.type === 'CallExpression' &&
node.parent.callee.type === 'MemberExpression' &&
node.parent.parent.type === 'ExpressionStatement' &&
// only indent if line breaks in between tokens
_tk.findInBetween(node.startToken, node.endToken, 'LineBreak');
}
exports.format = function ClassDeclarationAndExpression(node) {
var classKeyword = node.startToken;
var opening = tk.findNext(node.startToken, '{');
var closing = node.endToken;
// yes, we remove all the line breaks and limit to a single whitespace in
// between the words since line breaks here would increase complexity
tk.removeInBetween(classKeyword, opening, tk.isBr);
ws.limitAfter(classKeyword, 1);
var extendsKeyword = tk.findInBetween(classKeyword, opening, 'extends');
if (extendsKeyword) {
ws.limit(extendsKeyword, 1);
}
limit.around(opening, 'ClassOpeningBrace');
limit.around(closing, 'ClassClosingBrace');
};
exports.getIndentEdges = function(node) {
if (!node.elements.length) return;
var closingIsOnSeparateLine = _tk.findInBetween(
_tk.findPrevNonEmpty(node.endToken),
node.endToken,
_tk.isBr
);
return {
startToken: node.startToken,
endToken: closingIsOnSeparateLine ?
node.endToken :
_tk.findInBetweenFromEnd(node.startToken, node.endToken, _tk.isBr)
};
};
exports.getIndentEdges = function(node) {
// FIXME: maybe find a better way to abstract this kind of logic, this is
// related to bug #142 but unsure if we will have the same kind of error
// elsewhere.
if (node.parent.type === 'ArrayExpression') {
var isOnSeparateLine = _tk.findInBetween(
_tk.findPrevNonEmpty(node.startToken),
node.startToken,
_tk.isBr
);
return isOnSeparateLine ? node : null;
}
if (isChainedMemberExpressionArgument(node)) {
return {
startToken: node.startToken,
endToken: _tk.findPrev(node.endToken, 'LineBreak')
};
}
return node;
};
function containsCommentsInside(node) {
return !!_tk.findInBetween(node.startToken, node.endToken, _tk.isComment);
}
function hasBr(start, end) {
return _tk.findInBetween(start, end, _tk.isBr);
}
args.forEach(function(arg) {
var next = _tk.findInBetween(arg.endToken, closingParentheses, ',');
if (next && next.value === ',') {
_limit.around(next, 'ArgumentComma');
}
});
function isFirstNonEmptyTokenOfLine(token) {
if (!token.prev || tk.isBr(token.prev)) return true;
var prev = tk.findPrevNonEmpty(token);
return !prev ? true : tk.findInBetween(prev, token, tk.isBr);
}