semi-spacing.js
5.66 KB
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
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
/**
* @fileoverview Validates spacing before and after semicolon
* @author Mathias Schreck
* @copyright 2015 Mathias Schreck
*/
"use strict";
var astUtils = require("../ast-utils");
//------------------------------------------------------------------------------
// Rule Definition
//------------------------------------------------------------------------------
module.exports = function(context) {
var config = context.options[0],
requireSpaceBefore = false,
requireSpaceAfter = true,
sourceCode = context.getSourceCode();
if (typeof config === "object") {
if (config.hasOwnProperty("before")) {
requireSpaceBefore = config.before;
}
if (config.hasOwnProperty("after")) {
requireSpaceAfter = config.after;
}
}
/**
* Checks if a given token has leading whitespace.
* @param {Object} token The token to check.
* @returns {boolean} True if the given token has leading space, false if not.
*/
function hasLeadingSpace(token) {
var tokenBefore = context.getTokenBefore(token);
return tokenBefore && astUtils.isTokenOnSameLine(tokenBefore, token) && sourceCode.isSpaceBetweenTokens(tokenBefore, token);
}
/**
* Checks if a given token has trailing whitespace.
* @param {Object} token The token to check.
* @returns {boolean} True if the given token has trailing space, false if not.
*/
function hasTrailingSpace(token) {
var tokenAfter = context.getTokenAfter(token);
return tokenAfter && astUtils.isTokenOnSameLine(token, tokenAfter) && sourceCode.isSpaceBetweenTokens(token, tokenAfter);
}
/**
* Checks if the given token is the last token in its line.
* @param {Token} token The token to check.
* @returns {boolean} Whether or not the token is the last in its line.
*/
function isLastTokenInCurrentLine(token) {
var tokenAfter = context.getTokenAfter(token);
return !(tokenAfter && astUtils.isTokenOnSameLine(token, tokenAfter));
}
/**
* Checks if the given token is the first token in its line
* @param {Token} token The token to check.
* @returns {boolean} Whether or not the token is the first in its line.
*/
function isFirstTokenInCurrentLine(token) {
var tokenBefore = context.getTokenBefore(token);
return !(tokenBefore && astUtils.isTokenOnSameLine(token, tokenBefore));
}
/**
* Checks if the next token of a given token is a closing parenthesis.
* @param {Token} token The token to check.
* @returns {boolean} Whether or not the next token of a given token is a closing parenthesis.
*/
function isBeforeClosingParen(token) {
var nextToken = context.getTokenAfter(token);
return (
nextToken &&
nextToken.type === "Punctuator" &&
(nextToken.value === "}" || nextToken.value === ")")
);
}
/**
* Checks if the given token is a semicolon.
* @param {Token} token The token to check.
* @returns {boolean} Whether or not the given token is a semicolon.
*/
function isSemicolon(token) {
return token.type === "Punctuator" && token.value === ";";
}
/**
* Reports if the given token has invalid spacing.
* @param {Token} token The semicolon token to check.
* @param {ASTNode} node The corresponding node of the token.
* @returns {void}
*/
function checkSemicolonSpacing(token, node) {
var location;
if (isSemicolon(token)) {
location = token.loc.start;
if (hasLeadingSpace(token)) {
if (!requireSpaceBefore) {
context.report(node, location, "Unexpected whitespace before semicolon.");
}
} else {
if (requireSpaceBefore) {
context.report(node, location, "Missing whitespace before semicolon.");
}
}
if (!isFirstTokenInCurrentLine(token) && !isLastTokenInCurrentLine(token) && !isBeforeClosingParen(token)) {
if (hasTrailingSpace(token)) {
if (!requireSpaceAfter) {
context.report(node, location, "Unexpected whitespace after semicolon.");
}
} else {
if (requireSpaceAfter) {
context.report(node, location, "Missing whitespace after semicolon.");
}
}
}
}
}
/**
* Checks the spacing of the semicolon with the assumption that the last token is the semicolon.
* @param {ASTNode} node The node to check.
* @returns {void}
*/
function checkNode(node) {
var token = context.getLastToken(node);
checkSemicolonSpacing(token, node);
}
return {
"VariableDeclaration": checkNode,
"ExpressionStatement": checkNode,
"BreakStatement": checkNode,
"ContinueStatement": checkNode,
"DebuggerStatement": checkNode,
"ReturnStatement": checkNode,
"ThrowStatement": checkNode,
"ForStatement": function(node) {
if (node.init) {
checkSemicolonSpacing(context.getTokenAfter(node.init), node);
}
if (node.test) {
checkSemicolonSpacing(context.getTokenAfter(node.test), node);
}
}
};
};
module.exports.schema = [
{
"type": "object",
"properties": {
"before": {
"type": "boolean"
},
"after": {
"type": "boolean"
}
},
"additionalProperties": false
}
];