no-irregular-whitespace.js
4.56 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
/**
* @fileoverview Rule to disalow whitespace that is not a tab or space, whitespace inside strings and comments are allowed
* @author Jonathan Kingston
* @copyright 2014 Jonathan Kingston. All rights reserved.
*/
"use strict";
//------------------------------------------------------------------------------
// Rule Definition
//------------------------------------------------------------------------------
module.exports = function(context) {
var irregularWhitespace = /[\u0085\u00A0\ufeff\f\v\u00a0\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u200b\u202f\u205f\u3000]+/mg,
irregularLineTerminators = /[\u2028\u2029]/mg;
// Module store of errors that we have found
var errors = [];
/**
* Removes errors that occur inside a string node
* @param {ASTNode} node to check for matching errors.
* @returns {void}
* @private
*/
function removeStringError(node) {
var locStart = node.loc.start;
var locEnd = node.loc.end;
errors = errors.filter(function(error) {
var errorLoc = error[1];
if (errorLoc.line >= locStart.line && errorLoc.line <= locEnd.line) {
if (errorLoc.column >= locStart.column && (errorLoc.column <= locEnd.column || errorLoc.line < locEnd.line)) {
return false;
}
}
return true;
});
}
/**
* Checks nodes for errors that we are choosing to ignore and calls the relevant methods to remove the errors
* @param {ASTNode} node to check for matching errors.
* @returns {void}
* @private
*/
function removeInvalidNodeErrors(node) {
if (typeof node.value === "string") {
// If we have irregular characters remove them from the errors list
if (node.raw.match(irregularWhitespace) || node.raw.match(irregularLineTerminators)) {
removeStringError(node);
}
}
}
/**
* Checks the program source for irregular whitespace
* @param {ASTNode} node The program node
* @returns {void}
* @private
*/
function checkForIrregularWhitespace(node) {
var sourceLines = context.getSourceLines();
sourceLines.forEach(function(sourceLine, lineIndex) {
var lineNumber = lineIndex + 1,
location,
match;
while ((match = irregularWhitespace.exec(sourceLine)) !== null) {
location = {
line: lineNumber,
column: match.index
};
errors.push([node, location, "Irregular whitespace not allowed"]);
}
});
}
/**
* Checks the program source for irregular line terminators
* @param {ASTNode} node The program node
* @returns {void}
* @private
*/
function checkForIrregularLineTerminators(node) {
var source = context.getSource(),
sourceLines = context.getSourceLines(),
linebreaks = source.match(/\r\n|\r|\n|\u2028|\u2029/g),
lastLineIndex = -1,
lineIndex,
location,
match;
while ((match = irregularLineTerminators.exec(source)) !== null) {
lineIndex = linebreaks.indexOf(match[0], lastLineIndex + 1) || 0;
location = {
line: lineIndex + 1,
column: sourceLines[lineIndex].length
};
errors.push([node, location, "Irregular whitespace not allowed"]);
lastLineIndex = lineIndex;
}
}
return {
"Program": function(node) {
/**
* As we can easily fire warnings for all white space issues with all the source its simpler to fire them here
* This means we can check all the application code without having to worry about issues caused in the parser tokens
* When writing this code also evaluating per node was missing out connecting tokens in some cases
* We can later filter the errors when they are found to be not an issue in nodes we don't care about
*/
checkForIrregularWhitespace(node);
checkForIrregularLineTerminators(node);
},
"Identifier": removeInvalidNodeErrors,
"Literal": removeInvalidNodeErrors,
"Program:exit": function() {
// If we have any errors remaining report on them
errors.forEach(function(error) {
context.report.apply(context, error);
});
}
};
};
module.exports.schema = [];