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
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
|
/**
* @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({
node: mainNode,
loc: culpritToken.loc.start,
message: "Infix operators must be spaced.",
fix: function(fixer) {
var previousToken = context.getTokenBefore(culpritToken);
var afterToken = context.getTokenAfter(culpritToken);
var fixString = "";
if (culpritToken.range[0] - previousToken.range[1] === 0) {
fixString = " ";
}
fixString += culpritToken.value;
if (afterToken.range[0] - culpritToken.range[1] === 0) {
fixString += " ";
}
return fixer.replaceText(culpritToken, fixString);
}
});
}
/**
* Check if the node is binary then report
* @param {ASTNode} node node to evaluate
* @returns {void}
* @private
*/
function checkBinary(node) {
var nonSpacedNode = getFirstNonSpacedToken(node.left, node.right);
if (nonSpacedNode) {
if (!(int32Hint && context.getSource(node).substr(-2) === "|0")) {
report(node, nonSpacedNode);
}
}
}
/**
* Check if the node is conditional
* @param {ASTNode} node node to evaluate
* @returns {void}
* @private
*/
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);
}
}
/**
* Check if the node is a variable
* @param {ASTNode} node node to evaluate
* @returns {void}
* @private
*/
function checkVar(node) {
var nonSpacedNode;
if (node.init) {
nonSpacedNode = getFirstNonSpacedToken(node.id, node.init);
if (nonSpacedNode) {
report(node, nonSpacedNode);
}
}
}
return {
"AssignmentExpression": checkBinary,
"AssignmentPattern": checkBinary,
"BinaryExpression": checkBinary,
"LogicalExpression": checkBinary,
"ConditionalExpression": checkConditional,
"VariableDeclarator": checkVar
};
};
module.exports.schema = [
{
"type": "object",
"properties": {
"int32Hint": {
"type": "boolean"
}
},
"additionalProperties": false
}
];
|
