This rule checks to see that there is spacing before and after the arrow operator that declares a function. This rule is disabled by default.
Note that if arrow_spacing is enabled, and you pass an empty function as a parameter, arrow_spacing will accept either a space or no space in-between the arrow operator and the parenthesis
# Both of this will not trigger an error,
# even with arrow_spacing enabled.
x(-> 3)
x( -> 3)
# However, this will trigger an error
x((a,b)-> 3)
# Spaces is 0
{a: b} # Good
{a: b } # Bad
{ a: b} # Bad
{ a: b } # Bad
# Spaces is 1
{a: b} # Bad
{a: b } # Bad
{ a: b} # Bad
{ a: b } # Good
{ a: b } # Bad
{ a: b } # Bad
{ a: b } # Bad
# Empty Object Spaces is 0
{} # Good
{ } # Bad
# Empty Object Spaces is 1
{} # Bad
{ } # Good
# Mono Object Spaces is 0
{a} # Good
{ a } # Bad
# Mono Object Spaces is 1
{a} # Bad
{ a } # Good
# Spaces is 0
[a, b] # Good
[a, b ] # Bad
[ a, b] # Bad
[ a, b ] # Bad
# Except brackets
[ [a, b] ] # Good
[[ a, b ]] # Bad
# Spaces is 1
[a, b] # Bad
[a, b ] # Bad
[ a, b] # Bad
[ a, b ] # Good
[ a, b ] # Bad
[ a, b ] # Bad
[ a, b ] # Bad
# Except braces
[{ a: b }] # Good
[ {a: b} ] # Bad
# Empty Array Spaces is 0
[] # Good
[ ] # Bad
# Empty Array Spaces is 1
[] # Bad
[ ] # Good
# Mono Array Spaces is 0
[a] # Good
[ a ] # Bad
# Mono Array Spaces is 1
[a] # Bad
[ a ] # Good
# Good!
class BoaConstrictor
# Bad!
class boaConstrictor
This rule is enabled by default.`
};
CamelCaseClasses.prototype.tokens = ['CLASS'];
return CamelCaseClasses;
}).call(this);
},{}],13:[function(require,module,exports){
var ColonAssignmentSpacing;
module.exports = ColonAssignmentSpacing = (function() {
class ColonAssignmentSpacing {
lintToken(token, tokenApi) {
var checkSpacing, isLeftSpaced, isRightSpaced, nextToken, previousToken, spaceRules;
spaceRules = tokenApi.config[this.rule.name].spacing;
previousToken = tokenApi.peek(-1);
nextToken = tokenApi.peek(1);
checkSpacing = function(direction) {
var minDirection, spacing;
spacing = (function() {
switch (direction) {
case 'left':
return token[2].first_column - previousToken[2].last_column - 1;
case 'right':
return nextToken[2].first_column - token[2].first_column - 1;
}
})();
// when spacing is negative, the neighboring token is a newline
if (spacing < 0) {
return true;
} else {
minDirection = parseInt(spaceRules['min_' + direction], 10);
// if a minimal spacing is specified, only check that
if (minDirection >= 0) {
return spacing >= minDirection;
} else {
// otherwise check exact spacing
return spacing === parseInt(spaceRules[direction], 10);
}
}
};
isLeftSpaced = checkSpacing('left');
isRightSpaced = checkSpacing('right');
if (token.jsxColon || isLeftSpaced && isRightSpaced) {
return null;
} else {
return {
token: token,
context: `Incorrect spacing around column ${token[2].first_column}`
};
}
}
};
ColonAssignmentSpacing.prototype.rule = {
type: 'style',
name: 'colon_assignment_spacing',
level: 'ignore',
message: 'Colon assignment without proper spacing',
spacing: {
left: 0,
right: 0
},
description: `This rule checks to see that there is spacing before and after the colon in a colon assignment (i.e., classes, objects). The spacing amount is specified by spacing.left and spacing.right, respectively. A zero value means no spacing required.
#
# If spacing.left and spacing.right is 1
#
# Doesn't throw an error
object = {spacing : true}
class Dog
canBark : true
# Throws an error
object = {spacing: true}
class Cat
canBark: false
#
Enabling this option will prevent this ugly
# but otherwise valid CoffeeScript.
twoSpaces = () ->
fourSpaces = () ->
eightSpaces = () ->
'this is valid CoffeeScript'
Two space indentation is enabled by default.`
};
Indentation.prototype.tokens = ['INDENT', '[', ']', '.'];
Indentation.prototype.keywords = ['->', '=>', '@', 'CATCH', 'CLASS', 'DEFAULT', 'ELSE', 'EXPORT', 'FINALLY', 'FOR', 'FORIN', 'FOROF', 'IDENTIFIER', 'IF', 'IMPORT', 'LEADING_WHEN', 'LOOP', 'PROPERTY', 'RETURN', 'SWITCH', 'THROW', 'TRY', 'UNTIL', 'WHEN', 'WHILE', 'YIELD'];
return Indentation;
}).call(this);
},{}],20:[function(require,module,exports){
var LineEndings;
module.exports = LineEndings = (function() {
class LineEndings {
lintLine(line, lineApi) {
var ending, lastChar, ref, valid;
ending = (ref = lineApi.config[this.rule.name]) != null ? ref.value : void 0;
if (!ending || lineApi.isLastLine() || !line) {
return null;
}
lastChar = line[line.length - 1];
valid = (function() {
if (ending === 'windows') {
return lastChar === '\r';
} else if (ending === 'unix') {
return lastChar !== '\r';
} else {
throw new Error(`unknown line ending type: ${ending}`);
}
})();
if (!valid) {
return {
columnNumber: line.length,
context: `Expected ${ending}`
};
} else {
return null;
}
}
};
LineEndings.prototype.rule = {
type: 'problem',
name: 'line_endings',
level: 'ignore',
value: 'unix', // or 'windows'
message: 'Line contains incorrect line endings',
description: `This rule ensures your project uses only windows or
unix line endings. This rule is disabled by default.`
};
return LineEndings;
}).call(this);
},{}],21:[function(require,module,exports){
var MaxLineLength, regexes;
regexes = {
literateComment: /^\s*\#\s/, // indentation, up to comment followed by at least one space.
longUrlComment: /^\s*\#\s.*http[^\s]+.*$/ // indentation, up to comment followed by at least one space.
// Any string may precedes url
// Actual link
// Line may end by other things
};
module.exports = MaxLineLength = (function() {
class MaxLineLength {
lintLine(line, lineApi) {
var isCommentLine, limitComments, lineLength, max, ref, ref1;
max = (ref = lineApi.config[this.rule.name]) != null ? ref.value : void 0;
limitComments = (ref1 = lineApi.config[this.rule.name]) != null ? ref1.limitComments : void 0;
isCommentLine = regexes.literateComment.test(line);
lineLength = line.replace(/\s+$/, '').length;
if (lineApi.isLiterate() && isCommentLine) {
lineLength -= 2;
}
if (max && max < lineLength && !regexes.longUrlComment.test(line)) {
if (!limitComments) {
if (isCommentLine) {
return;
}
}
return {
columnNumber: max,
context: `Length is ${lineLength}, max is ${max}`
};
}
}
};
MaxLineLength.prototype.rule = {
type: 'style',
name: 'max_line_length',
value: 80,
level: 'error',
limitComments: true,
message: 'Line exceeds maximum allowed length',
description: `This rule imposes a maximum line length on your code. Python's style
guide does a good job explaining why you might want to limit the
length of your lines, though this is a matter of taste.
Lines can be no longer than eighty characters by default.`
};
return MaxLineLength;
}).call(this);
},{}],22:[function(require,module,exports){
var MissingFatArrows, any, containsButIsnt,
indexOf = [].indexOf;
any = function(arr, test) {
return arr.reduce((function(res, elt) {
return res || test(elt);
}), false);
};
containsButIsnt = function(node, nIsThis, nIsClass) {
var target;
target = void 0;
node.traverseChildren(false, function(n) {
if (nIsClass(n)) {
return false;
}
if (nIsThis(n)) {
target = n;
return false;
}
});
return target;
};
module.exports = MissingFatArrows = (function() {
class MissingFatArrows {
constructor() {
this.isCode = this.isCode.bind(this);
this.isClass = this.isClass.bind(this);
this.isValue = this.isValue.bind(this);
this.isObject = this.isObject.bind(this);
this.isThis = this.isThis.bind(this);
this.isFatArrowCode = this.isFatArrowCode.bind(this);
}
lintAST(node, astApi) {
this.astApi = astApi;
this.lintNode(node);
return void 0;
}
lintNode(node, methods = []) {
var error, isStrict, ref;
isStrict = (ref = this.astApi.config[this.rule.name]) != null ? ref.is_strict : void 0;
if (this.isPrototype(node)) {
return;
}
if (this.isConstructor(node)) {
return;
}
// Ignore any nodes we know to be methods
if ((!this.isFatArrowCode(node)) && (isStrict ? true : indexOf.call(methods, node) < 0) && (this.needsFatArrow(node))) {
error = this.astApi.createError({
lineNumber: node.locationData.first_line + 1,
columnNumber: node.locationData.first_column + 1
});
this.errors.push(error);
}
return node.eachChild((child) => {
return this.lintNode(child, (function() {
switch (false) {
case !this.isClass(node):
return this.methodsOfClass(node);
// Once we've hit a function, we know we can't be in the top
// level of a method anymore, so we can safely reset the methods
// to empty to save work.
case !this.isCode(node):
return [];
default:
return methods;
}
}).call(this));
});
}
isCode(node) {
return this.astApi.getNodeName(node) === 'Code';
}
isClass(node) {
return this.astApi.getNodeName(node) === 'Class';
}
isValue(node) {
return this.astApi.getNodeName(node) === 'Value';
}
isObject(node) {
return this.astApi.getNodeName(node) === 'Obj';
}
isPrototype(node) {
var i, ident, len, props, ref, ref1;
props = (node != null ? (ref = node.variable) != null ? ref.properties : void 0 : void 0) || [];
for (i = 0, len = props.length; i < len; i++) {
ident = props[i];
if (((ref1 = ident.name) != null ? ref1.value : void 0) === 'prototype') {
return true;
}
}
return false;
}
isThis(node) {
return this.isValue(node) && node.base.value === 'this';
}
isFatArrowCode(node) {
return this.isCode(node) && node.bound;
}
isConstructor(node) {
var ref, ref1;
return ((ref = node.variable) != null ? (ref1 = ref.base) != null ? ref1.value : void 0 : void 0) === 'constructor';
}
needsFatArrow(node) {
return this.isCode(node) && (any(node.params, (param) => {
return param.contains(this.isThis) != null;
}) || containsButIsnt(node.body, this.isThis, this.isClass));
}
methodsOfClass(classNode) {
var bodyNodes, returnNode;
bodyNodes = classNode.body.expressions;
returnNode = bodyNodes[bodyNodes.length - 1];
if ((returnNode != null) && this.isValue(returnNode) && this.isObject(returnNode.base)) {
return returnNode.base.properties.map(function(assignNode) {
return assignNode.value;
}).filter(this.isCode);
} else {
return [];
}
}
};
MissingFatArrows.prototype.rule = {
type: 'problem',
name: 'missing_fat_arrows',
level: 'ignore',
is_strict: false,
message: 'Used `this` in a function without a fat arrow',
description: `Warns when you use \`this\` inside a function that wasn't defined
with a fat arrow. This rule does not apply to methods defined in a
class, since they have \`this\` bound to the class instance (or the
class itself, for class methods). The option \`is_strict\` is
available for checking bindings of class methods.
It is impossible to statically determine whether a function using
\`this\` will be bound with the correct \`this\` value due to language
features like \`Function.prototype.call\` and
\`Function.prototype.bind\`, so this rule may produce false positives.`
};
return MissingFatArrows;
}).call(this);
},{}],23:[function(require,module,exports){
var ParseintRadix;
module.exports = ParseintRadix = (function() {
class ParseintRadix {
lintToken(token, tokenApi) {
var callEnd, functionName, prevToken;
[prevToken, functionName] = tokenApi.peek(-1);
if (functionName === 'parseInt') {
[callEnd] = tokenApi.peek(2);
if (callEnd === 'CALL_END') {
return {token};
}
}
}
};
ParseintRadix.prototype.rule = {
type: 'problem',
name: 'missing_parseint_radix',
level: 'warn',
message: 'parseInt is missing the radix argument',
description: `This rule warns about using parseInt without a radix. From the MDN
developers reference: Always specify this parameter to eliminate reader confusion and to guarantee predictable behavior.
# You would expect this to result in 8, but
# it might result in 0 (parsed as octal).
parseInt '08'
# To be safe, specify the radix argument:
parseInt '08', 10
`
};
ParseintRadix.prototype.tokens = ['CALL_START'];
return ParseintRadix;
}).call(this);
},{}],24:[function(require,module,exports){
var NewlinesAfterClasses;
module.exports = NewlinesAfterClasses = (function() {
class NewlinesAfterClasses {
lintToken(token, tokenApi) {
var afters, comment, ending, got, lineNumber, lines, numIndents, outdent, ref, ref1, start, trueLine, type;
[
type,
numIndents,
{
first_line: lineNumber
}
] = token;
({lines} = tokenApi);
ending = tokenApi.config[this.rule.name].value;
if (type === 'CLASS') {
this.classCount++;
}
if (this.classCount > 0 && (token.generated != null)) {
if (type === '{' && ((ref = token.origin) != null ? ref[0] : void 0) === ':') {
this.classBracesCount++;
}
if (type === '}' && ((ref1 = token.origin) != null ? ref1[0] : void 0) === 'OUTDENT') {
this.classBracesCount--;
this.classCount--;
if (this.classCount === 0 && this.classBracesCount === 0) {
afters = 1;
comment = 0;
outdent = token.origin[2].first_line;
start = Math.min(lineNumber, outdent);
trueLine = start + 1;
while (/^\s*(#|$)/.test(lines[start + afters])) {
if (/^\s*#/.test(lines[start + afters])) {
comment += 1;
}
afters += 1;
}
// add up blank lines, subtract comments, subtract 2 because
// before/after counters started at 1.
got = afters - comment - 1;
// if `got` and `ending` don't match throw an error _unless_
// we are at the end of the file.
if (got !== ending && trueLine + got !== lines.length) {
return {
context: `Expected ${ending} got ${got}`,
lineNumber: trueLine
};
}
}
}
}
}
};
NewlinesAfterClasses.prototype.rule = {
type: 'style',
name: 'newlines_after_classes',
value: 3,
level: 'ignore',
message: 'Wrong count of blank lines between a class and other code',
description: `Checks the number of blank lines between classes and other code.
Options: -value
someFunctionWithCallback ->
doSomethingSignificant()
The problem is that the call to
doSomethingSignificant will be made regardless
of someFunctionWithCallback's execution. It can
be because you did not indent the call to
doSomethingSignificant properly.
If you really meant that someFunctionWithCallback
should call a callback that does nothing, you can write your code
this way:
someFunctionWithCallback ->
undefined
doSomethingSignificant()
`
};
return NoEmptyFunctions;
}).call(this);
},{}],28:[function(require,module,exports){
var NoEmptyParamList;
module.exports = NoEmptyParamList = (function() {
class NoEmptyParamList {
lintToken(token, tokenApi) {
var nextType;
nextType = tokenApi.peek()[0];
if (nextType === 'PARAM_END') {
return {token};
}
}
};
NoEmptyParamList.prototype.rule = {
type: 'style',
name: 'no_empty_param_list',
level: 'ignore',
message: 'Empty parameter list is forbidden',
description: `This rule prohibits empty parameter lists in function definitions.
# The empty parameter list in here is unnecessary:
myFunction = () ->
# We might favor this instead:
myFunction = ->
Empty parameter lists are permitted by default.`
};
NoEmptyParamList.prototype.tokens = ['PARAM_START'];
return NoEmptyParamList;
}).call(this);
},{}],29:[function(require,module,exports){
var NoImplicitBraces,
slice = [].slice;
module.exports = NoImplicitBraces = (function() {
class NoImplicitBraces {
constructor() {
this.isClass = false;
this.className = '';
}
lintToken(token, tokenApi) {
var _type, _val, c, lineNum, peekIdent, prevToken, ref, type, val;
[type, val, lineNum] = token;
if (type === 'OUTDENT' || type === 'INDENT' || type === 'CLASS') {
return this.trackClass(...arguments);
}
// reset "className" if class uses EXTENDS keyword
if (type === 'EXTENDS') {
this.className = '';
return;
}
// If we're looking at an IDENTIFIER, and we're in a class, and we've not
// set a className (or the previous non-identifier was 'EXTENDS', set the
// current identifier as the class name)
if ((type === 'IDENTIFIER' || type === 'PROPERTY') && this.isClass && this.className === '') {
// Backtrack to get the full classname
c = 0;
while ((ref = tokenApi.peek(c)[0]) === 'IDENTIFIER' || ref === 'PROPERTY' || ref === '.') {
this.className += tokenApi.peek(c)[1];
c++;
}
}
if (token.generated && type === '{') {
// If strict mode is set to false it allows implicit braces when the
// object is declared over multiple lines.
if (!tokenApi.config[this.rule.name].strict) {
[prevToken] = tokenApi.peek(-1);
if (prevToken === 'INDENT' || prevToken === 'TERMINATOR') {
return;
}
}
if (this.isClass) {
// The way CoffeeScript generates tokens for classes
// is a bit weird. It generates '{' tokens around instance
// methods (also known as the prototypes of an Object).
[prevToken] = tokenApi.peek(-1);
// If there is a TERMINATOR token right before the '{' token
if (prevToken === 'TERMINATOR') {
return;
}
peekIdent = '';
c = -2;
// Go back until you grab all the tokens with IDENTIFIER,
// PROPERTY or '.'
while (([_type, _val] = tokenApi.peek(c))) {
if (_type !== 'IDENTIFIER' && _type !== 'PROPERTY' && _type !== '.') {
break;
}
peekIdent = _val + peekIdent;
c--;
}
if (peekIdent === this.className) {
return;
}
}
return {
token: tokenApi.peek(c + 1)
};
}
}
trackClass(token, tokenApi) {
var ln, n0, n1, ref, ref1, ref2;
ref = [token, tokenApi.peek()], (ref1 = ref[0], [n0] = ref1, [ln] = slice.call(ref1, -1)), (ref2 = ref[1], [n1] = ref2);
if (n0 === 'INDENT') {
this.dent++;
}
if (n0 === 'OUTDENT') {
this.dent--;
}
if (this.dent === 0 && n0 === 'OUTDENT' && n1 === 'TERMINATOR') {
this.isClass = false;
}
if (n0 === 'CLASS') {
this.isClass = true;
this.className = '';
}
return null;
}
};
NoImplicitBraces.prototype.rule = {
type: 'style',
name: 'no_implicit_braces',
level: 'ignore',
message: 'Implicit braces are forbidden',
strict: true,
description: `This rule prohibits implicit braces when declaring object literals.
Implicit braces can make code more difficult to understand,
especially when used in combination with optional parenthesis.
# Do you find this code ambiguous? Is it a
# function call with three arguments or four?
myFunction a, b, 1:2, 3:4
# While the same code written in a more
# explicit manner has no ambiguity.
myFunction(a, b, {1:2, 3:4})
Implicit braces are permitted by default, since their use is
idiomatic CoffeeScript.`
};
NoImplicitBraces.prototype.tokens = ['{', 'OUTDENT', 'INDENT', 'CLASS', 'IDENTIFIER', 'PROPERTY', 'EXTENDS'];
NoImplicitBraces.prototype.dent = 0;
return NoImplicitBraces;
}).call(this);
},{}],30:[function(require,module,exports){
var NoImplicitParens;
module.exports = NoImplicitParens = (function() {
class NoImplicitParens {
lintToken(token, tokenApi) {
var genCallStart, i, sameLine, t;
if (token.generated) {
if (tokenApi.config[this.rule.name].strict !== false) {
return {token};
} else {
// If strict mode is turned off it allows implicit parens when
// the expression is spread over multiple lines.
i = -1;
while (true) {
t = tokenApi.peek(i);
sameLine = t[2].first_line === token[2].first_line;
genCallStart = t[0] === 'CALL_START' && t.generated;
if ((t == null) || genCallStart && sameLine) {
return {
token: t || token
};
}
// If we have not found a CALL_START token that is generated,
// and we've moved into a new line, this is fine and should
// just return.
if (!sameLine) {
return null;
}
i -= 1;
}
}
}
}
};
NoImplicitParens.prototype.rule = {
type: 'style',
name: 'no_implicit_parens',
level: 'ignore',
message: 'Implicit parens are forbidden',
strict: true,
description: `This rule prohibits implicit parens on function calls.
# Some folks don't like this style of coding.
myFunction a, b, c
# And would rather it always be written like this:
myFunction(a, b, c)
Implicit parens are permitted by default, since their use is
idiomatic CoffeeScript.`
};
NoImplicitParens.prototype.tokens = ['CALL_END'];
return NoImplicitParens;
}).call(this);
},{}],31:[function(require,module,exports){
var NoInterpolationInSingleQuotes;
module.exports = NoInterpolationInSingleQuotes = (function() {
class NoInterpolationInSingleQuotes {
lintToken(token, tokenApi) {
var hasInterpolation, tokenValue;
tokenValue = token[1];
hasInterpolation = tokenValue.match(/^.*#\{[^}]+\}.*$/);
if (hasInterpolation) {
return {token};
}
}
};
NoInterpolationInSingleQuotes.prototype.rule = {
type: 'problem',
name: 'no_interpolation_in_single_quotes',
level: 'ignore',
message: 'Interpolation in single quoted strings is forbidden',
description: `This rule prohibits string interpolation in a single quoted string.
# String interpolation in single quotes is not allowed:
foo = '#{bar}'
# Double quotes is OK of course
foo = "#{bar}"
String interpolation in single quoted strings is permitted by
default.`
};
NoInterpolationInSingleQuotes.prototype.tokens = ['STRING'];
return NoInterpolationInSingleQuotes;
}).call(this);
},{}],32:[function(require,module,exports){
var NoNestedStringInterpolation;
module.exports = NoNestedStringInterpolation = (function() {
class NoNestedStringInterpolation {
constructor() {
this.blocks = [];
}
lintToken(token, tokenApi) {
var block, ref, tag, tagname, tagtype;
[tag] = token;
if (!this.blocks.length) {
this.blocks.push([]);
}
block = this.blocks[this.blocks.length - 1];
if (tag === 'JSX_TAG') {
this.blocks.push([]);
return;
}
[tagname, tagtype] = tag.split('_');
if (tagtype === 'END') {
block.pop();
if (tagname === 'STRING') {
block.strCount -= 1;
if (block.strCount <= 1) {
block.error = false;
}
} else {
this.blocks.pop();
}
if (!block.length) {
this.blocks.pop();
}
if (!this.blocks.length) {
this.blocks.push([]);
}
} else {
block.push(tagname);
if (tagname === 'STRING') {
block.strCount = ((ref = block.strCount) != null ? ref : 0) + 1;
// Don't make multiple errors for deeply nested interpolation
if (block.strCount > 1 && !block.error) {
block.error = true;
return {token};
}
}
}
}
};
NoNestedStringInterpolation.prototype.rule = {
type: 'problem',
name: 'no_nested_string_interpolation',
level: 'warn',
message: 'Nested string interpolation is forbidden',
description: `This rule warns about nested string interpolation,
as it tends to make code harder to read and understand.
# Good!
str = "Book by #{firstName.toUpperCase()} #{lastName.toUpperCase()}"
# Bad!
str = "Book by #{"#{firstName} #{lastName}".toUpperCase()}"
`
};
NoNestedStringInterpolation.prototype.tokens = ['JSX_TAG', 'CALL_START', 'CALL_END', 'STRING_START', 'STRING_END'];
return NoNestedStringInterpolation;
}).call(this);
},{}],33:[function(require,module,exports){
var NoPlusPlus;
module.exports = NoPlusPlus = (function() {
class NoPlusPlus {
lintToken(token, tokenApi) {
return {
token,
context: `found '${token[0]}'`
};
}
};
NoPlusPlus.prototype.rule = {
type: 'style',
name: 'no_plusplus',
level: 'ignore',
message: 'The increment and decrement operators are forbidden',
description: `This rule forbids the increment and decrement arithmetic operators.
Some people believe the ++ and -- to be cryptic
and the cause of bugs due to misunderstandings of their precedence
rules.
This rule is disabled by default.`
};
NoPlusPlus.prototype.tokens = ['++', '--'];
return NoPlusPlus;
}).call(this);
},{}],34:[function(require,module,exports){
var NoPrivateFunctionFatArrows,
indexOf = [].indexOf;
module.exports = NoPrivateFunctionFatArrows = (function() {
class NoPrivateFunctionFatArrows {
constructor() {
this.isCode = this.isCode.bind(this);
this.isClass = this.isClass.bind(this);
this.isValue = this.isValue.bind(this);
this.isObject = this.isObject.bind(this);
this.isFatArrowCode = this.isFatArrowCode.bind(this);
}
lintAST(node, astApi) {
this.astApi = astApi;
this.lintNode(node);
return void 0;
}
lintNode(node, functions = []) {
var error;
if (this.isFatArrowCode(node) && indexOf.call(functions, node) >= 0) {
error = this.astApi.createError({
lineNumber: node.locationData.first_line + 1,
columnNumber: node.locationData.first_column + 1
});
this.errors.push(error);
}
return node.eachChild((child) => {
return this.lintNode(child, (function() {
switch (false) {
case !this.isClass(node):
return this.functionsOfClass(node);
// Once we've hit a function, we know we can't be in the top
// level of a function anymore, so we can safely reset the
// functions to empty to save work.
case !this.isCode(node):
return [];
default:
return functions;
}
}).call(this));
});
}
isCode(node) {
return this.astApi.getNodeName(node) === 'Code';
}
isClass(node) {
return this.astApi.getNodeName(node) === 'Class';
}
isValue(node) {
return this.astApi.getNodeName(node) === 'Value';
}
isObject(node) {
return this.astApi.getNodeName(node) === 'Obj';
}
isFatArrowCode(node) {
return this.isCode(node) && node.bound;
}
functionsOfClass(classNode) {
var bodyNode, bodyValues;
bodyValues = (function() {
var i, len, ref, results;
ref = classNode.body.expressions;
results = [];
for (i = 0, len = ref.length; i < len; i++) {
bodyNode = ref[i];
if (this.isValue(bodyNode) && this.isObject(bodyNode.base)) {
continue;
}
results.push(bodyNode.value);
}
return results;
}).call(this);
return bodyValues.filter(this.isCode);
}
};
NoPrivateFunctionFatArrows.prototype.rule = {
type: 'style',
name: 'no_private_function_fat_arrows',
level: 'warn',
message: 'Used the fat arrow for a private function',
description: `Warns when you use the fat arrow for a private function
inside a class definition scope. It is not necessary and
it does not do anything.`
};
return NoPrivateFunctionFatArrows;
}).call(this);
},{}],35:[function(require,module,exports){
var NoSpaces, indentationRegex,
indexOf = [].indexOf;
indentationRegex = /\S/;
module.exports = NoSpaces = (function() {
class NoSpaces {
lintLine(line, lineApi) {
var indentation;
// Only check lines that have compiled tokens. This helps
// us ignore spaces in the middle of multi line strings, heredocs, etc.
// since they are all reduced to a single token whose line number
// is the start of the expression.
indentation = line.split(indentationRegex)[0];
if (lineApi.lineHasToken() && indexOf.call(indentation, '\ ') >= 0) {
return true;
} else {
return null;
}
}
};
NoSpaces.prototype.rule = {
type: 'style',
name: 'no_spaces',
level: 'ignore',
message: 'Line contains space indentation',
description: `This rule forbids spaces in indentation. It is disabled by default.`
};
return NoSpaces;
}).call(this);
},{}],36:[function(require,module,exports){
var NoStandAloneAt;
module.exports = NoStandAloneAt = (function() {
class NoStandAloneAt {
lintToken(token, tokenApi) {
var isAStart, isDot, isProp, isProtoProp, nextToken, noSpace, ref, ref1;
[nextToken] = tokenApi.peek();
noSpace = !token.spaced;
isProp = nextToken === 'PROPERTY';
isAStart = nextToken === 'INDEX_START' || nextToken === 'CALL_START'; // @[] or @()
isDot = nextToken === '.';
// https://github.com/jashkenas/coffee-script/issues/1601
// @::foo is valid, but @:: behaves inconsistently and is planned for
// removal. Technically @:: is a stand alone ::, but I think it makes
// sense to group it into no_stand_alone_at
isProtoProp = nextToken === '::' && ((ref = (ref1 = tokenApi.peek(2)) != null ? ref1[0] : void 0) === 'PROPERTY');
// Return an error after an '@' token unless:
// 1: there is a '.' afterwards (isDot)
// 2: there isn't a space after the '@' and the token following the '@'
// is an property, the start of an index '[' or is an property after
// the '::'
if (!(isDot || (noSpace && (isProp || isAStart || isProtoProp)))) {
return {token};
}
}
};
NoStandAloneAt.prototype.rule = {
type: 'style',
name: 'no_stand_alone_at',
level: 'ignore',
message: '@ must not be used stand alone',
description: `This rule checks that no stand alone @ are in use, they are
discouraged. Further information in CoffeeScript issue
#1601`
};
NoStandAloneAt.prototype.tokens = ['@'];
return NoStandAloneAt;
}).call(this);
},{}],37:[function(require,module,exports){
var NoTabs, indentationRegex,
indexOf = [].indexOf;
indentationRegex = /\S/;
module.exports = NoTabs = (function() {
class NoTabs {
lintLine(line, lineApi) {
var indentation;
// Only check lines that have compiled tokens. This helps
// us ignore tabs in the middle of multi line strings, heredocs, etc.
// since they are all reduced to a single token whose line number
// is the start of the expression.
indentation = line.split(indentationRegex)[0];
if (lineApi.lineHasToken() && indexOf.call(indentation, '\t') >= 0) {
return {
columnNumber: indentation.indexOf('\t')
};
} else if (lineApi.lineHasToken() && line.match(/\t *$/)) {
return {
columnNumber: indentation.indexOf('\t')
};
} else {
return null;
}
}
};
NoTabs.prototype.rule = {
type: 'style',
name: 'no_tabs',
level: 'error',
message: 'Line contains tab indentation',
description: `This rule forbids tabs in indentation. Enough said. It is enabled by
default.`
};
return NoTabs;
}).call(this);
},{}],38:[function(require,module,exports){
var NoThis;
module.exports = NoThis = (function() {
class NoThis {
lintToken(token, tokenApi) {
var level, nextToken, ref;
({
config: {
no_stand_alone_at: {level}
}
} = tokenApi);
nextToken = (ref = tokenApi.peek(1)) != null ? ref[0] : void 0;
if (!(level !== 'ignore' && nextToken !== '.')) {
return {token};
}
}
};
NoThis.prototype.rule = {
type: 'style',
name: 'no_this',
level: 'ignore',
message: "Don't use 'this', use '@' instead",
description: `This rule prohibits 'this'.
Use '@' instead.`
};
NoThis.prototype.tokens = ['THIS'];
return NoThis;
}).call(this);
},{}],39:[function(require,module,exports){
var NoThrowingStrings;
module.exports = NoThrowingStrings = (function() {
class NoThrowingStrings {
lintToken(token, tokenApi) {
var n1, nextIsString, ref;
ref = tokenApi.peek(), [n1] = ref;
// Catch literals and string interpolations, which are wrapped in parens.
nextIsString = n1 === 'STRING' || n1 === 'STRING_START';
if (nextIsString) {
return {token};
}
}
};
NoThrowingStrings.prototype.rule = {
type: 'problem',
name: 'no_throwing_strings',
level: 'error',
message: 'Throwing strings is forbidden',
description: `This rule forbids throwing string literals or interpolations. While
JavaScript (and CoffeeScript by extension) allow any expression to
be thrown, it is best to only throw Error objects,
because they contain valuable debugging information like the stack
trace. Because of JavaScript's dynamic nature, CoffeeLint cannot
ensure you are always throwing instances of Error. It will
only catch the simple but real case of throwing literal strings.
# CoffeeLint will catch this:
throw "i made a boo boo"
# ... but not this:
throw getSomeString()
This rule is enabled by default.`
};
NoThrowingStrings.prototype.tokens = ['THROW'];
return NoThrowingStrings;
}).call(this);
},{}],40:[function(require,module,exports){
var NoTrailingSemicolons, regexes,
indexOf = [].indexOf,
splice = [].splice;
regexes = {
trailingSemicolon: /;\r?$/
};
module.exports = NoTrailingSemicolons = (function() {
class NoTrailingSemicolons {
lintLine(line, lineApi) {
var endPos, first, hasNewLine, hasSemicolon, last, lineTokens, newLine, ref, ref1, ref2, startCounter, startPos, stopTokens, tokenLen;
// The TERMINATOR token is extended through to the next token. As a
// result a line with a comment DOES have a token: the TERMINATOR from
// the last line of code.
lineTokens = lineApi.getLineTokens();
tokenLen = lineTokens.length;
stopTokens = ['TERMINATOR', 'HERECOMMENT'];
if (tokenLen === 1 && (ref = lineTokens[0][0], indexOf.call(stopTokens, ref) >= 0)) {
return;
}
if (tokenLen === 2 && lineTokens[1].generated && (ref1 = lineTokens[0][0], indexOf.call(stopTokens, ref1) >= 0)) {
return;
}
newLine = line;
if (tokenLen > 1 && lineTokens[tokenLen - 1][0] === 'TERMINATOR') {
// `startPos` contains the end pos of the last non-TERMINATOR token
// `endPos` contains the start position of the TERMINATOR token
// if startPos and endPos arent equal, that probably means a comment
// was sliced out of the tokenizer
startPos = lineTokens[tokenLen - 2][2].last_column + 1;
endPos = lineTokens[tokenLen - 1][2].first_column;
if (startPos !== endPos) {
startCounter = startPos;
while (line[startCounter] !== '#' && startCounter < line.length) {
startCounter++;
}
newLine = line.substring(0, startCounter).replace(/\s*$/, '');
}
}
hasSemicolon = regexes.trailingSemicolon.test(newLine);
[...first] = lineTokens, [last] = splice.call(first, -1);
hasNewLine = last && (last.newLine != null);
// Don't throw errors when the contents of multiline strings,
// regexes and the like end in ";"
if (hasSemicolon && !hasNewLine && lineApi.lineHasToken() && !((ref2 = last[0]) === 'STRING' || ref2 === 'IDENTIFIER' || ref2 === 'STRING_END')) {
return true;
}
}
};
NoTrailingSemicolons.prototype.rule = {
type: 'style',
name: 'no_trailing_semicolons',
level: 'error',
message: 'Line contains a trailing semicolon',
description: `This rule prohibits trailing semicolons, since they are needless
cruft in CoffeeScript.
# This semicolon is meaningful.
x = '1234'; console.log(x)
# This semicolon is redundant.
alert('end of line');
Trailing semicolons are forbidden by default.`
};
return NoTrailingSemicolons;
}).call(this);
},{}],41:[function(require,module,exports){
var NoTrailingWhitespace, regexes;
regexes = {
trailingWhitespace: /[^\s]+[\t ]+\r?$/,
onlySpaces: /^[\t ]+\r?$/,
spacesStart: /[\t ]+\r?$/,
lineHasComment: /^\s*[^\#]*\#/
};
module.exports = NoTrailingWhitespace = (function() {
class NoTrailingWhitespace {
lintLine(line, lineApi) {
var i, len, ref, ref1, ref2, str, token, tokens;
if (!((ref = lineApi.config['no_trailing_whitespace']) != null ? ref.allowed_in_empty_lines : void 0)) {
if (regexes.onlySpaces.test(line)) {
return {
columnNumber: line.match(regexes.spacesStart).length + 1
};
}
}
if (regexes.trailingWhitespace.test(line)) {
// By default only the regex above is needed.
if (!((ref1 = lineApi.config['no_trailing_whitespace']) != null ? ref1.allowed_in_comments : void 0)) {
return {
columnNumber: line.match(regexes.spacesStart).index + 1
};
}
line = line;
tokens = lineApi.tokensByLine[lineApi.lineNumber];
if (!tokens) {
return null;
}
ref2 = (function() {
var j, len, results;
results = [];
for (j = 0, len = tokens.length; j < len; j++) {
token = tokens[j];
if (token[0] === 'STRING') {
results.push(token[1]);
}
}
return results;
})();
// To avoid confusion when a string might contain a "#", every string
// on this line will be removed. before checking for a comment
for (i = 0, len = ref2.length; i < len; i++) {
str = ref2[i];
line = line.replace(str, 'STRING');
}
if (!regexes.lineHasComment.test(line)) {
return {
columnNumber: line.match(regexes.spacesStart).index + 1
};
}
}
}
};
NoTrailingWhitespace.prototype.rule = {
type: 'style',
name: 'no_trailing_whitespace',
level: 'error',
message: 'Line ends with trailing whitespace',
allowed_in_comments: false,
allowed_in_empty_lines: true,
description: `This rule forbids trailing whitespace in your code, since it is
needless cruft. It is enabled by default.`
};
return NoTrailingWhitespace;
}).call(this);
},{}],42:[function(require,module,exports){
var NoUnnecessaryDoubleQuotes;
module.exports = NoUnnecessaryDoubleQuotes = (function() {
class NoUnnecessaryDoubleQuotes {
constructor() {
this.regexps = [];
this.interpolationLevel = 0;
this.inJSX = false;
this.JSXCallLevel = 0;
}
lintToken(token, tokenApi) {
var hasLegalConstructs, isSingleBlock, isSingleQuote, ref, tokenValue, type;
[type, tokenValue] = token;
if (type === 'STRING_START' || type === 'STRING_END') {
return this.trackInterpolation(...arguments);
}
if (type === 'JSX_TAG' || type === 'CALL_START' || type === 'CALL_END') {
return this.trackJSX(...arguments);
}
isSingleQuote = tokenValue.quote === "'";
isSingleBlock = tokenValue.quote === "'''";
if (isSingleQuote || isSingleBlock) { // no double quotes, all OK
return false;
}
// When CoffeeScript generates calls to RegExp it double quotes the 2nd
// parameter. Using peek(2) becuase the peek(1) would be a CALL_END
if (((ref = tokenApi.peek(2)) != null ? ref[0] : void 0) === 'REGEX_END') {
return false;
}
hasLegalConstructs = this.inJSX || this.isInInterpolation() || this.hasSingleQuote(tokenValue);
if (!hasLegalConstructs) {
return {token};
}
}
isInInterpolation() {
return this.interpolationLevel > 0;
}
trackInterpolation(token, tokenApi) {
if (token[0] === 'STRING_START') {
this.interpolationLevel += 1;
} else if (token[0] === 'STRING_END') {
this.interpolationLevel -= 1;
}
// We're not linting, just tracking interpolations.
return null;
}
trackJSX(token, tokenApi) {
if (token[0] === 'JSX_TAG') {
this.inJSX = true;
} else if (token[0] === 'CALL_START') {
if (this.inJSX) {
this.JSXCallLevel += 1;
}
} else if (token[0] === 'CALL_END') {
if (this.inJSX) {
this.JSXCallLevel -= 1;
if (this.JSXCallLevel === 0) {
this.inJSX = false;
}
}
}
// We're not linting, just tracking interpolations.
return null;
}
hasSingleQuote(tokenValue) {
return tokenValue.indexOf("'") !== -1;
}
};
NoUnnecessaryDoubleQuotes.prototype.rule = {
type: 'style',
name: 'no_unnecessary_double_quotes',
level: 'ignore',
message: 'Unnecessary double quotes are forbidden',
description: `This rule prohibits double quotes unless string interpolation is
used or the string contains single quotes.
# Double quotes are discouraged:
foo = "bar"
# Unless string interpolation is used:
foo = "#{bar}baz"
# Or they prevent cumbersome escaping:
foo = "I'm just following the 'rules'"
Double quotes are permitted by default.`
};
NoUnnecessaryDoubleQuotes.prototype.tokens = ['STRING', 'STRING_START', 'STRING_END', 'JSX_TAG', 'CALL_START', 'CALL_END'];
return NoUnnecessaryDoubleQuotes;
}).call(this);
},{}],43:[function(require,module,exports){
var NoUnnecessaryFatArrows, any;
any = function(arr, test) {
return arr.reduce((function(res, elt) {
return res || test(elt);
}), false);
};
module.exports = NoUnnecessaryFatArrows = (function() {
class NoUnnecessaryFatArrows {
constructor() {
this.isThis = this.isThis.bind(this);
this.needsFatArrow = this.needsFatArrow.bind(this);
}
lintAST(node, astApi) {
this.astApi = astApi;
this.lintNode(node);
return void 0;
}
lintNode(node) {
var error;
if ((this.isFatArrowCode(node)) && (!this.needsFatArrow(node))) {
error = this.astApi.createError({
lineNumber: node.locationData.first_line + 1,
columnNumber: node.locationData.first_column + 1
});
this.errors.push(error);
}
return node.eachChild((child) => {
return this.lintNode(child);
});
}
isCode(node) {
return this.astApi.getNodeName(node) === 'Code';
}
isFatArrowCode(node) {
return this.isCode(node) && node.bound;
}
isValue(node) {
return this.astApi.getNodeName(node) === 'Value';
}
isThis(node) {
var ref;
return ((ref = node.constructor) != null ? ref.name : void 0) === 'ThisLiteral' || this.isValue(node) && node.base.value === 'this';
}
needsFatArrow(node) {
return this.isCode(node) && (any(node.params, (param) => {
return param.contains(this.isThis) != null;
}) || (node.body.contains(this.isThis) != null) || (node.body.contains((child) => {
var ref;
if (!this.astApi.getNodeName(child)) {
return ((ref = child.constructor) != null ? ref.name : void 0) === 'SuperCall';
} else {
return this.isFatArrowCode(child) && this.needsFatArrow(child);
}
}) != null));
}
};
NoUnnecessaryFatArrows.prototype.rule = {
type: 'style',
name: 'no_unnecessary_fat_arrows',
level: 'warn',
message: 'Unnecessary fat arrow',
description: `Disallows defining functions with fat arrows when \`this\`
is not used within the function.`
};
return NoUnnecessaryFatArrows;
}).call(this);
},{}],44:[function(require,module,exports){
var NonEmptyConstructorNeedsParens, ParentClass;
ParentClass = require('./empty_constructor_needs_parens.coffee');
module.exports = NonEmptyConstructorNeedsParens = (function() {
class NonEmptyConstructorNeedsParens extends ParentClass {
handleExpectedCallStart(isCallStart, tokenApi) {
if (isCallStart[0] === 'CALL_START' && isCallStart.generated) {
return {
token: tokenApi.peek(isCallStart, 1)
};
}
}
};
NonEmptyConstructorNeedsParens.prototype.rule = {
type: 'style',
name: 'non_empty_constructor_needs_parens',
level: 'ignore',
message: 'Invoking a constructor without parens and with arguments',
description: `Requires constructors with parameters to include the parens`
};
return NonEmptyConstructorNeedsParens;
}).call(this);
},{"./empty_constructor_needs_parens.coffee":16}],45:[function(require,module,exports){
var ObjectShorthand;
module.exports = ObjectShorthand = (function() {
class ObjectShorthand {
lintToken(token, tokenApi) {
var checkExplicit, explicit, property, value;
checkExplicit = function() {
var current;
current = -2;
while (tokenApi.peek(current)[0] !== '{') {
current--;
}
return !tokenApi.peek(current).generated;
};
// Get the property name and the value
property = tokenApi.peek(-1);
value = tokenApi.peek(1);
// Check if we have explicit {}
explicit = checkExplicit();
if (explicit && property[1] === value[1]) {
return {
context: `Use '{${property[1]}}'`
};
} else {
return null;
}
}
};
ObjectShorthand.prototype.rule = {
type: 'style',
name: 'object_shorthand',
level: 'ignore',
message: 'Use property-value shorthand when using explicit braces',
description: `Use property value shorthand in objects, when explicit braces are used.
test = "value"
# Good
{test}
test: test
# Bad
{test: test}
# ignore_elision: true
[,, c,, e, f] = [1, 2, 3, 4, 5, 6]