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
|
/**
* @fileoverview Require spaces around infix operators
* @author Michael Ficarra
*/
"use strict";
//------------------------------------------------------------------------------
// Rule Definition
//------------------------------------------------------------------------------
module.exports = function(context) {
var int32Hint = context.options[0] ? context.options[0].int32Hint === true : false;
var OPERATORS = [
"*", "/", "%", "+", "-", "<<", ">>", ">>>", "<", "<=", ">", ">=", "in",
"instanceof", "==", "!=", "===", "!==", "&", "^", "|", "&&", "||", "=",
"+=", "-=", "*=", "/=", "%=", "<<=", ">>=", ">>>=", "&=", "^=", "|=",
"?", ":", ","
];
/**
* Returns the first token which violates the rule
* @param {ASTNode} left - The left node of the main node
* @param {ASTNode} right - The right node of the main node
* @returns {object} The violator token or null
* @private
*/
function getFirstNonSpacedToken(left, right) {
var op, tokens = context.getTokensBetween(left, right, 1);
for (var i = 1, l = tokens.length - 1; i < l; ++i) {
op = tokens[i];
if (
op.type === "Punctuator" &&
OPERATORS.indexOf(op.value) >= 0 &&
(tokens[i - 1].range[1] >= op.range[0] || op.range[1] >= tokens[i + 1].range[0])
) {
return op;
}
}
return null;
}
/**
* Reports an AST node as a rule violation
* @param {ASTNode} mainNode - The node to report
* @param {object} culpritToken - The token which has a problem
* @returns {void}
* @private
*/
function report(mainNode, culpritToken) {
context.report(mainNode, culpritToken.loc.start, "Infix operators must be spaced.");
}
function checkBinary(node) {
var nonSpacedNode = getFirstNonSpacedToken(node.left, node.right);
if (nonSpacedNode) {
if (!(int32Hint && context.getSource(node).substr(-2) === "|0")) {
report(node, nonSpacedNode);
}
}
}
function checkConditional(node) {
var nonSpacedConsequesntNode = getFirstNonSpacedToken(node.test, node.consequent);
var nonSpacedAlternateNode = getFirstNonSpacedToken(node.consequent, node.alternate);
if (nonSpacedConsequesntNode) {
report(node, nonSpacedConsequesntNode);
} else if (nonSpacedAlternateNode) {
report(node, nonSpacedAlternateNode);
}
}
function checkVar(node) {
var nonSpacedNode;
if (node.init) {
nonSpacedNode = getFirstNonSpacedToken(node.id, node.init);
if (nonSpacedNode) {
report(node, nonSpacedNode);
}
}
}
return {
"AssignmentExpression": checkBinary,
"BinaryExpression": checkBinary,
"LogicalExpression": checkBinary,
"ConditionalExpression": checkConditional,
"VariableDeclarator": checkVar
};
};
module.exports.schema = [
{
"type": "object",
"properties": {
"int32Hint": {
"type": "boolean"
}
},
"additionalProperties": false
}
];
|
