default level: <%= level %>
19 |
12 | # The empty parameter list in here is unnecessary:
13 | myFunction = () ->
14 |
15 | # We might favor this instead:
16 | myFunction = ->
17 |
18 |
19 | Empty parameter lists are permitted by default.
20 | """
21 |
22 | tokens: [ "PARAM_START" ]
23 |
24 | lintToken : (token, tokenApi) ->
25 | nextType = tokenApi.peek()[0]
26 | return nextType is 'PARAM_END'
27 |
28 |
--------------------------------------------------------------------------------
/test/test_plusplus.coffee:
--------------------------------------------------------------------------------
1 | path = require 'path'
2 | vows = require 'vows'
3 | assert = require 'assert'
4 | coffeelint = require path.join('..', 'lib', 'coffeelint')
5 |
6 |
7 | vows.describe('plusplus').addBatch({
8 |
9 | 'The increment and decrement operators' :
10 |
11 | topic : '''
12 | y++
13 | ++y
14 | x--
15 | --x
16 | '''
17 |
18 | 'are permitted by default' : (source) ->
19 | errors = coffeelint.lint(source)
20 | assert.isArray(errors)
21 | assert.isEmpty(errors)
22 |
23 | 'can be forbidden' : (source) ->
24 | errors = coffeelint.lint(source, {no_plusplus: {'level':'error'}})
25 | assert.isArray(errors)
26 | assert.lengthOf(errors, 4)
27 | error = errors[0]
28 | assert.equal(error.lineNumber, 1)
29 | assert.equal(error.rule, 'no_plusplus')
30 |
31 | }).export(module)
32 |
--------------------------------------------------------------------------------
/src/rules/newlines_after_classes.coffee:
--------------------------------------------------------------------------------
1 |
2 | module.exports = class NewlinesAfterClasses
3 |
4 | rule:
5 | name: 'newlines_after_classes'
6 | value : 3
7 | level : 'ignore'
8 | message : 'Wrong count of newlines between a class and other code'
9 | description: "Checks the number of newlines between classes and other
10 | code"
11 |
12 | lintLine: (line, lineApi) ->
13 | ending = lineApi.config[@rule.name].value
14 |
15 | return null if not ending or lineApi.isLastLine()
16 |
17 | { lineNumber, context } = lineApi
18 | if not context.class.inClass and
19 | context.class.lastUnemptyLineInClass? and
20 | (lineNumber - context.class.lastUnemptyLineInClass) isnt
21 | ending
22 | got = lineNumber - context.class.lastUnemptyLineInClass
23 | return { context: "Expected #{ending} got #{got}" }
24 |
25 | null
26 |
27 |
--------------------------------------------------------------------------------
/test/test_backticks.coffee:
--------------------------------------------------------------------------------
1 | path = require 'path'
2 | vows = require 'vows'
3 | assert = require 'assert'
4 | coffeelint = require path.join('..', 'lib', 'coffeelint')
5 |
6 | vows.describe('backticks').addBatch({
7 |
8 | 'Backticks' :
9 |
10 | topic : "`with(document) alert(height);`"
11 |
12 | 'are forbidden by default' : (source) ->
13 | errors = coffeelint.lint(source)
14 | assert.isArray(errors)
15 | assert.lengthOf(errors, 1)
16 | error = errors[0]
17 | assert.equal(error.rule, 'no_backticks')
18 | assert.equal(error.lineNumber, 1)
19 | assert.equal(error.message, "Backticks are forbidden")
20 |
21 | 'can be permitted' : (source) ->
22 | config = {no_backticks : {level:'ignore'}}
23 | errors = coffeelint.lint(source, config)
24 | assert.isArray(errors)
25 | assert.isEmpty(errors)
26 |
27 | }).export(module)
28 |
29 |
--------------------------------------------------------------------------------
/test/test_throw.coffee:
--------------------------------------------------------------------------------
1 | path = require 'path'
2 | vows = require 'vows'
3 | assert = require 'assert'
4 | coffeelint = require path.join('..', 'lib', 'coffeelint')
5 |
6 | vows.describe('throw').addBatch({
7 |
8 | 'Throwing strings' :
9 |
10 | topic : '''
11 | throw 'my error'
12 | throw "#{1234}"
13 | throw """
14 | long string
15 | """
16 | '''
17 |
18 | 'is forbidden by default' : (source) ->
19 | errors = coffeelint.lint(source)
20 | assert.lengthOf(errors, 3)
21 | error = errors[0]
22 | assert.equal(error.message, 'Throwing strings is forbidden')
23 | assert.equal(error.rule, 'no_throwing_strings')
24 |
25 | 'can be permitted' : (source) ->
26 | config = {no_throwing_strings : {level : 'ignore'}}
27 | errors = coffeelint.lint(source, config)
28 | assert.isEmpty(errors)
29 |
30 | }).export(module)
31 |
--------------------------------------------------------------------------------
/src/rules/no_interpolation_in_single_quotes.coffee:
--------------------------------------------------------------------------------
1 |
2 |
3 | module.exports = class NoInterpolationInSingleQuotes
4 |
5 | rule:
6 | name: 'no_interpolation_in_single_quotes'
7 | level: 'ignore'
8 | message: 'Interpolation in single quoted strings is forbidden'
9 | description: '''
10 | This rule prohibits string interpolation in a single quoted string.
11 |
12 | # String interpolation in single quotes is not allowed:
13 | foo = '#{bar}'
14 |
15 | # Double quotes is OK of course
16 | foo = "#{bar}"
17 |
18 |
19 | String interpolation in single quoted strings is permitted by
20 | default.
21 | '''
22 |
23 | tokens: [ 'STRING' ]
24 |
25 | lintToken : (token, tokenApi) ->
26 | tokenValue = token[1]
27 |
28 | hasInterpolation = tokenValue.match(/#\{[^}]+\}/)
29 | return hasInterpolation
30 |
--------------------------------------------------------------------------------
/src/rules/line_endings.coffee:
--------------------------------------------------------------------------------
1 |
2 |
3 | module.exports = class LineEndings
4 |
5 | rule:
6 | name: 'line_endings'
7 | level : 'ignore'
8 | value : 'unix' # or 'windows'
9 | message : 'Line contains incorrect line endings'
10 | description: """
11 | This rule ensures your project uses only windows or
12 | unix line endings. This rule is disabled by default.
13 | """
14 |
15 | lintLine: (line, lineApi) ->
16 | ending = lineApi.config[@rule.name]?.value
17 |
18 | return null if not ending or lineApi.isLastLine() or not line
19 |
20 | lastChar = line[line.length - 1]
21 | valid = if ending == 'windows'
22 | lastChar == '\r'
23 | else if ending == 'unix'
24 | lastChar != '\r'
25 | else
26 | throw new Error("unknown line ending type: #{ending}")
27 | if not valid
28 | return {context:"Expected #{ending}"}
29 | else
30 | return null
31 |
--------------------------------------------------------------------------------
/test/test_empty_param_list.coffee:
--------------------------------------------------------------------------------
1 | path = require 'path'
2 | vows = require 'vows'
3 | assert = require 'assert'
4 | coffeelint = require path.join('..', 'lib', 'coffeelint')
5 |
6 | vows.describe('params').addBatch({
7 |
8 | 'Empty param list' :
9 |
10 | topic : () ->
11 | '''
12 | blah = () ->
13 | '''
14 |
15 | 'are allowed by default' : (source) ->
16 | errors = coffeelint.lint(source)
17 | assert.isArray(errors)
18 | assert.isEmpty(errors)
19 |
20 | 'can be forbidden' : (source) ->
21 | config = {no_empty_param_list : {level:'error'}}
22 | errors = coffeelint.lint(source, config)
23 | assert.isArray(errors)
24 | assert.lengthOf(errors, 1)
25 | error = errors[0]
26 | assert.equal(error.lineNumber, 1)
27 | assert.equal(error.message, 'Empty parameter list is forbidden')
28 | assert.equal(error.rule, 'no_empty_param_list')
29 |
30 | }).export(module)
31 |
--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
1 | CoffeeLint
2 | Copyright (c) 2011 Matthew Perpick
3 |
4 | Permission is hereby granted, free of charge, to any person obtaining a copy
5 | of this software and associated documentation files (the "Software"), to deal
6 | in the Software without restriction, including without limitation the rights
7 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
8 | copies of the Software, and to permit persons to whom the Software is
9 | furnished to do so, subject to the following conditions:
10 |
11 | The above copyright notice and this permission notice shall be included in
12 | all copies or substantial portions of the Software.
13 |
14 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
15 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
17 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
18 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
19 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
20 | THE SOFTWARE.
21 |
--------------------------------------------------------------------------------
/test/test_debugger.coffee:
--------------------------------------------------------------------------------
1 | path = require 'path'
2 | vows = require 'vows'
3 | assert = require 'assert'
4 | coffeelint = require path.join('..', 'lib', 'coffeelint')
5 |
6 |
7 | vows.describe('no_debugger').addBatch({
8 |
9 | 'The debugger statement' :
10 |
11 | topic : ->
12 | '''
13 | debugger
14 | '''
15 |
16 | 'causes a warning when present' : (source) ->
17 | errors = coffeelint.lint(source)
18 | assert.isArray(errors)
19 | assert.lengthOf(errors, 1)
20 | error = errors[0]
21 | assert.equal(error.level, 'warn')
22 | assert.equal(error.lineNumber, 1)
23 | assert.equal(error.rule, 'no_debugger')
24 |
25 | 'can be set to error' : (source) ->
26 | errors = coffeelint.lint(source, {no_debugger: {'level':'error'}})
27 | assert.isArray(errors)
28 | assert.isArray(errors)
29 | assert.lengthOf(errors, 1)
30 | error = errors[0]
31 | assert.equal(error.lineNumber, 1)
32 | assert.equal(error.rule, 'no_debugger')
33 |
34 | }).export(module)
35 |
--------------------------------------------------------------------------------
/test/test_literate.litcoffee:
--------------------------------------------------------------------------------
1 | The post-test process involves linting all of the files under `test/`. By
2 | writing this file in Literate (style?) it verifies that literate files are
3 | automatically detected.
4 |
5 |
6 | path = require 'path'
7 | vows = require 'vows'
8 | assert = require 'assert'
9 | coffeelint = require path.join('..', 'lib', 'coffeelint')
10 |
11 | vows.describe('literate').addBatch({
12 |
13 | Markdown uses trailing spaces to force a line break.
14 |
15 | 'Trailing whitespace in markdown' :
16 |
17 | topic :
18 |
19 | The line of code is written weird because I had trouble getting the 4 space
20 | prefix in place.
21 |
22 | """This is some `Markdown`. \n\n
23 | \n x = 1234 \n y = 1
24 | """
25 |
26 | 'is ignored' : (source) ->
27 |
28 | The 3rd parameter here indicates that the incoming source is literate.
29 |
30 | errors = coffeelint.lint(source, {}, true)
31 |
32 | This intentionally includes trailing whitespace in code so it also verifies
33 | that the way `Markdown` spaces are stripped are not also stripping code.
34 |
35 | assert.equal(errors.length, 1)
36 |
37 | }).export(module)
38 |
--------------------------------------------------------------------------------
/src/rules/no_stand_alone_at.coffee:
--------------------------------------------------------------------------------
1 |
2 | module.exports = class NoStandAloneAt
3 |
4 | rule:
5 | name: 'no_stand_alone_at'
6 | level : 'ignore'
7 | message : '@ must not be used stand alone'
8 | description: """
9 | This rule checks that no stand alone @ are in use, they are
10 | discouraged. Further information in CoffeScript issue
12 | #1601
13 | """
14 |
15 |
16 | tokens: [ "@" ]
17 |
18 | lintToken : (token, tokenApi) ->
19 | nextToken = tokenApi.peek()
20 | spaced = token.spaced
21 | isIdentifier = nextToken[0] == 'IDENTIFIER'
22 | isIndexStart = nextToken[0] == 'INDEX_START'
23 | isDot = nextToken[0] == '.'
24 |
25 | # https://github.com/jashkenas/coffee-script/issues/1601
26 | # @::foo is valid, but @:: behaves inconsistently and is planned for
27 | # removal. Technically @:: is a stand alone ::, but I think it makes
28 | # sense to group it into no_stand_alone_at
29 | if nextToken[0] == '::'
30 | protoProperty = tokenApi.peek(2)
31 | isValidProtoProperty = protoProperty[0] == 'IDENTIFIER'
32 |
33 | if spaced or (not isIdentifier and not isIndexStart and
34 | not isDot and not isValidProtoProperty)
35 | return true
36 |
37 |
38 |
39 |
--------------------------------------------------------------------------------
/src/rules/no_implicit_parens.coffee:
--------------------------------------------------------------------------------
1 |
2 | module.exports = class NoImplicitParens
3 |
4 | rule:
5 | name: 'no_implicit_parens'
6 | strict : true
7 | level : 'ignore'
8 | message : 'Implicit parens are forbidden'
9 | description: """
10 | This rule prohibits implicit parens on function calls.
11 |
12 | # Some folks don't like this style of coding.
13 | myFunction a, b, c
14 |
15 | # And would rather it always be written like this:
16 | myFunction(a, b, c)
17 |
18 |
19 | Implicit parens are permitted by default, since their use is
20 | idiomatic CoffeeScript.
21 | """
22 |
23 |
24 | tokens: [ "CALL_END" ]
25 |
26 | lintToken : (token, tokenApi) ->
27 | if token.generated
28 | unless tokenApi.config[@rule.name].strict == false
29 | return true
30 | else
31 | # If strict mode is turned off it allows implicit parens when the
32 | # expression is spread over multiple lines.
33 | i = -1
34 | loop
35 | t = tokenApi.peek(i)
36 | if not t? or t[0] == 'CALL_START'
37 | return true
38 | if t.newLine
39 | return null
40 | i -= 1
41 |
--------------------------------------------------------------------------------
/src/rules/no_unnecessary_fat_arrows.coffee:
--------------------------------------------------------------------------------
1 | any = (arr, test) -> arr.reduce ((res, elt) -> res or test elt), false
2 |
3 | module.exports = class NoUnnecessaryFatArrows
4 |
5 | rule:
6 | name: 'no_unnecessary_fat_arrows'
7 | level: 'warn'
8 | message: 'Unnecessary fat arrow'
9 | description: """
10 | Disallows defining functions with fat arrows when `this`
11 | is not used within the function.
12 | """
13 |
14 | lintAST: (node, @astApi) ->
15 | @lintNode node
16 | undefined
17 |
18 | lintNode: (node) ->
19 | if (@isFatArrowCode node) and (not @needsFatArrow node)
20 | error = @astApi.createError
21 | lineNumber: node.locationData.first_line + 1
22 | @errors.push error
23 | node.eachChild (child) => @lintNode child
24 |
25 | isCode: (node) -> @astApi.getNodeName(node) is 'Code'
26 | isFatArrowCode: (node) -> @isCode(node) and node.bound
27 | isValue: (node) -> @astApi.getNodeName(node) is 'Value'
28 |
29 | isThis: (node) =>
30 | @isValue(node) and node.base.value is 'this'
31 |
32 |
33 | needsFatArrow: (node) =>
34 | @isCode(node) and (
35 | any(node.params, (param) => param.contains(@isThis)?) or
36 | node.body.contains(@isThis)? or
37 | node.body.contains((child) =>
38 | @isFatArrowCode(child) and @needsFatArrow(child))?
39 | )
40 |
--------------------------------------------------------------------------------
/test/test_levels.coffee:
--------------------------------------------------------------------------------
1 | path = require 'path'
2 | vows = require 'vows'
3 | assert = require 'assert'
4 | coffeelint = require path.join('..', 'lib', 'coffeelint')
5 |
6 | vows.describe('levels').addBatch({
7 |
8 | 'CoffeeLint' :
9 |
10 | topic : "abc = 123;",
11 |
12 | 'can ignore errors' : (source) ->
13 | config =
14 | no_trailing_semicolons : {level: 'ignore'}
15 | errors = coffeelint.lint(source, config)
16 | assert.isEmpty(errors)
17 |
18 | 'can return warnings' : (source) ->
19 | config =
20 | no_trailing_semicolons : {level: 'warn'}
21 | errors = coffeelint.lint(source, config)
22 | assert.isArray(errors)
23 | assert.lengthOf(errors, 1)
24 | error = errors[0]
25 | assert.equal(error.level, 'warn')
26 |
27 | 'can return errors' : (source) ->
28 | config =
29 | no_trailing_semicolons : {level: 'error'}
30 | errors = coffeelint.lint(source, config)
31 | assert.isArray(errors)
32 | assert.lengthOf(errors, 1)
33 | error = errors[0]
34 | assert.equal(error.level, 'error')
35 |
36 | 'catches unknown levels' : (source) ->
37 |
38 | config =
39 | no_trailing_semicolons : {level: 'foobar'}
40 | assert.throws () ->
41 | coffeelint.lint(source, config)
42 |
43 |
44 | }).export(module)
45 |
--------------------------------------------------------------------------------
/src/rules/no_throwing_strings.coffee:
--------------------------------------------------------------------------------
1 |
2 | module.exports = class NoThrowingStrings
3 |
4 | rule:
5 | name: 'no_throwing_strings'
6 | level : 'error'
7 | message : 'Throwing strings is forbidden'
8 | description: """
9 | This rule forbids throwing string literals or interpolations. While
10 | JavaScript (and CoffeeScript by extension) allow any expression to
11 | be thrown, it is best to only throw Error objects,
14 | because they contain valuable debugging information like the stack
15 | trace. Because of JavaScript's dynamic nature, CoffeeLint cannot
16 | ensure you are always throwing instances of Error. It will
17 | only catch the simple but real case of throwing literal strings.
18 |
19 | # CoffeeLint will catch this:
20 | throw "i made a boo boo"
21 |
22 | # ... but not this:
23 | throw getSomeString()
24 |
25 |
26 | This rule is enabled by default.
27 | """
28 |
29 | tokens: [ "THROW" ]
30 |
31 | lintToken : (token, tokenApi) ->
32 | [n1, n2] = [tokenApi.peek(), tokenApi.peek(2)]
33 | # Catch literals and string interpolations, which are wrapped in
34 | # parens.
35 | nextIsString = n1[0] == 'STRING' or (n1[0] == '(' and n2[0] == 'STRING')
36 | return nextIsString
37 |
--------------------------------------------------------------------------------
/test/test_no_stand_alone_at.coffee:
--------------------------------------------------------------------------------
1 | path = require 'path'
2 | vows = require 'vows'
3 | assert = require 'assert'
4 | coffeelint = require path.join('..', 'lib', 'coffeelint')
5 |
6 | vows.describe('stand alone @').addBatch({
7 |
8 | 'Stand alone @' :
9 |
10 | topic : () ->
11 | """
12 | @alright
13 | @ .error
14 | @ok()
15 | @ notok
16 | @[ok]
17 | @.ok
18 | not(@).ok
19 | @::ok
20 | @:: #notok
21 | """
22 |
23 | 'are allowed by default' : (source) ->
24 | errors = coffeelint.lint(source)
25 | assert.isArray(errors)
26 | assert.isEmpty(errors)
27 |
28 | 'can be forbidden' : (source) ->
29 | config = {no_stand_alone_at : {level:'error'}}
30 | errors = coffeelint.lint(source, config)
31 | assert.isArray(errors)
32 | assert.lengthOf(errors, 4)
33 | error = errors[0]
34 | assert.equal(error.lineNumber, 2)
35 | assert.equal(error.rule, 'no_stand_alone_at')
36 | error = errors[1]
37 | assert.equal(error.lineNumber, 4)
38 | assert.equal(error.rule, 'no_stand_alone_at')
39 | error = errors[2]
40 | assert.equal(error.lineNumber, 7)
41 | assert.equal(error.rule, 'no_stand_alone_at')
42 | error = errors[3]
43 | assert.equal(error.lineNumber, 9)
44 | assert.equal(error.rule, 'no_stand_alone_at')
45 |
46 | }).export(module)
47 |
--------------------------------------------------------------------------------
/src/rules/empty_constructor_needs_parens.coffee:
--------------------------------------------------------------------------------
1 |
2 | module.exports = class EmptyConstructorNeedsParens
3 |
4 | rule:
5 | name: 'empty_constructor_needs_parens'
6 | level: 'ignore'
7 | message: 'Invoking a constructor without parens and without arguments'
8 | description:
9 | "Requires constructors with no parameters to include the parens"
10 |
11 | tokens: [ 'UNARY' ]
12 |
13 | # Return an error if the given indentation token is not correct.
14 | lintToken: (token, tokenApi) ->
15 | if token[1] is 'new'
16 | # Find the last chained identifier, e.g. Bar in new foo.bar.Bar().
17 | identifierIndex = 1
18 | loop
19 | expectedIdentifier = tokenApi.peek(identifierIndex)
20 | expectedCallStart = tokenApi.peek(identifierIndex + 1)
21 | if expectedIdentifier?[0] is 'IDENTIFIER'
22 | if expectedCallStart?[0] is '.'
23 | identifierIndex += 2
24 | continue
25 | break
26 |
27 | # The callStart is generated if your parameters are all on the same
28 | # line with implicit parens, and if your parameters start on the
29 | # next line, but is missing if there are no params and no parens.
30 | if expectedIdentifier?[0] is 'IDENTIFIER' and expectedCallStart?
31 | return @handleExpectedCallStart expectedCallStart
32 |
33 | handleExpectedCallStart: (expectedCallStart) ->
34 | if expectedCallStart[0] isnt 'CALL_START'
35 | return true
36 |
--------------------------------------------------------------------------------
/src/rules/max_line_length.coffee:
--------------------------------------------------------------------------------
1 |
2 | regexes =
3 | literateComment: ///
4 | ^
5 | \#\s # This is prefixed on MarkDown lines.
6 | ///
7 | longUrlComment : ///
8 | ^\s*\# # indentation, up to comment
9 | \s*
10 | http[^\s]+$ # Link that takes up the rest of the line without spaces.
11 | ///
12 |
13 | module.exports = class MaxLineLength
14 |
15 | rule:
16 | name: 'max_line_length'
17 | value: 80
18 | level : 'error'
19 | limitComments: true
20 | message : 'Line exceeds maximum allowed length'
21 | description: """
22 | This rule imposes a maximum line length on your code. Python's style
24 | guide does a good job explaining why you might want to limit the
25 | length of your lines, though this is a matter of taste.
26 |
27 | Lines can be no longer than eighty characters by default.
28 | """
29 |
30 | lintLine: (line, lineApi) ->
31 | max = lineApi.config[@rule.name]?.value
32 | limitComments = lineApi.config[@rule.name]?.limitComments
33 |
34 | lineLength = line.length
35 | if lineApi.isLiterate() and regexes.literateComment.test(line)
36 | lineLength -= 2
37 |
38 | if max and max < lineLength and not regexes.longUrlComment.test(line)
39 |
40 | unless limitComments
41 | if lineApi.getLineTokens().length is 0
42 | return
43 |
44 | return {
45 | context: "Length is #{lineLength}, max is #{max}"
46 | }
47 |
--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
1 | {
2 | "name": "coffeelint",
3 | "description": "Lint your CoffeeScript",
4 | "version": "1.2.0",
5 | "homepage": "http://www.coffeelint.org",
6 | "keywords": [
7 | "lint",
8 | "coffeescript",
9 | "coffee-script"
10 | ],
11 | "author": "Matthew Perpick
17 | # Good!
18 | class BoaConstrictor
19 |
20 | # Bad!
21 | class boaConstrictor
22 |
23 |
24 | This rule is enabled by default.
25 | """
26 |
27 | tokens: [ 'CLASS' ]
28 |
29 | lintToken: (token, tokenApi) ->
30 | # TODO: you can do some crazy shit in CoffeeScript, like
31 | # class func().ClassName. Don't allow that.
32 |
33 | # Don't try to lint the names of anonymous classes.
34 | if token.newLine? or tokenApi.peek()[0] in ['INDENT', 'EXTENDS']
35 | return null
36 |
37 | # It's common to assign a class to a global namespace, e.g.
38 | # exports.MyClassName, so loop through the next tokens until
39 | # we find the real identifier.
40 | className = null
41 | offset = 1
42 | until className
43 | if tokenApi.peek(offset + 1)?[0] == '.'
44 | offset += 2
45 | else if tokenApi.peek(offset)?[0] == '@'
46 | offset += 1
47 | else
48 | className = tokenApi.peek(offset)[1]
49 |
50 | # Now check for the error.
51 | if not regexes.camelCase.test(className)
52 | return {context: "class name: #{className}"}
53 |
--------------------------------------------------------------------------------
/src/rules/cyclomatic_complexity.coffee:
--------------------------------------------------------------------------------
1 | module.exports = class NoTabs
2 |
3 | rule:
4 | name: 'cyclomatic_complexity'
5 | value : 10
6 | level : 'ignore'
7 | message : 'The cyclomatic complexity is too damn high'
8 | description : 'Examine the complexity of your application.'
9 |
10 | # returns the "complexity" value of the current node.
11 | getComplexity : (node) ->
12 | name = @astApi.getNodeName node
13 | complexity = if name in ['If', 'While', 'For', 'Try']
14 | 1
15 | else if name == 'Op' and node.operator in ['&&', '||']
16 | 1
17 | else if name == 'Switch'
18 | node.cases.length
19 | else
20 | 0
21 | return complexity
22 |
23 | lintAST : (node, @astApi) ->
24 | @lintNode node
25 | undefined
26 |
27 | # Lint the AST node and return its cyclomatic complexity.
28 | lintNode : (node, line) ->
29 |
30 | # Get the complexity of the current node.
31 | name = @astApi?.getNodeName node
32 | complexity = @getComplexity(node)
33 |
34 | # Add the complexity of all child's nodes to this one.
35 | node.eachChild (childNode) =>
36 | nodeLine = childNode.locationData.first_line
37 | complexity += @lintNode(childNode, nodeLine) if childNode
38 |
39 | rule = @astApi.config[@rule.name]
40 |
41 | # If the current node is a function, and it's over our limit, add an
42 | # error to the list.
43 | if name == 'Code' and complexity >= rule.value
44 | error = @astApi.createError {
45 | context: complexity + 1
46 | lineNumber: line + 1
47 | lineNumberEnd: node.locationData.last_line + 1
48 | }
49 | @errors.push error if error
50 |
51 | # Return the complexity for the benefit of parent nodes.
52 | return complexity
53 |
--------------------------------------------------------------------------------
/src/rules/no_implicit_braces.coffee:
--------------------------------------------------------------------------------
1 |
2 | module.exports = class NoImplicitBraces
3 |
4 | rule:
5 | name: 'no_implicit_braces'
6 | level : 'ignore'
7 | message : 'Implicit braces are forbidden'
8 | strict: true
9 | description: """
10 | This rule prohibits implicit braces when declaring object literals.
11 | Implicit braces can make code more difficult to understand,
12 | especially when used in combination with optional parenthesis.
13 |
14 | # Do you find this code ambiguous? Is it a
15 | # function call with three arguments or four?
16 | myFunction a, b, 1:2, 3:4
17 |
18 | # While the same code written in a more
19 | # explicit manner has no ambiguity.
20 | myFunction(a, b, {1:2, 3:4})
21 |
22 |
23 | Implicit braces are permitted by default, since their use is
24 | idiomatic CoffeeScript.
25 | """
26 |
27 | tokens: [ "{" ]
28 |
29 | lintToken: (token, tokenApi) ->
30 | if token.generated
31 |
32 | # If strict mode is turned off it allows implicit braces when the
33 | # object is declared over multiple lines.
34 | unless tokenApi.config[@rule.name].strict
35 | [ previousToken ] = tokenApi.peek(-1)
36 | if previousToken is 'INDENT'
37 | return
38 |
39 | @isPartOfClass(tokenApi)
40 |
41 |
42 | isPartOfClass: (tokenApi) ->
43 | # Peek back to the last line break. If there is a class
44 | # definition, ignore the generated brace.
45 | i = -1
46 | loop
47 | t = tokenApi.peek(i)
48 | if not t? or t[0] == 'TERMINATOR'
49 | return true
50 | if t[0] == 'CLASS'
51 | return null
52 | i -= 1
53 |
--------------------------------------------------------------------------------
/src/base_linter.coffee:
--------------------------------------------------------------------------------
1 | # Patch the source properties onto the destination.
2 | extend = (destination, sources...) ->
3 | for source in sources
4 | (destination[k] = v for k, v of source)
5 | return destination
6 |
7 | # Patch any missing attributes from defaults to source.
8 | defaults = (source, defaults) ->
9 | extend({}, defaults, source)
10 |
11 | module.exports = class BaseLinter
12 |
13 | constructor: (@source, @config, rules) ->
14 | @setupRules rules
15 |
16 | isObject: (obj) ->
17 | obj is Object(obj)
18 |
19 | # Create an error object for the given rule with the given
20 | # attributes.
21 | createError: (ruleName, attrs = {}) ->
22 |
23 | # Level should default to what's in the config, but can be overridden.
24 | attrs.level ?= @config[ruleName].level
25 |
26 | level = attrs.level
27 | if level not in ['ignore', 'warn', 'error']
28 | throw new Error("unknown level #{level}")
29 |
30 | if level in ['error', 'warn']
31 | attrs.rule = ruleName
32 | return defaults(attrs, @config[ruleName])
33 | else
34 | null
35 |
36 | acceptRule: (rule) ->
37 | throw new Error "acceptRule needs to be overridden in the subclass"
38 |
39 | # Only rules that have a level of error or warn will even get constructed.
40 | setupRules: (rules) ->
41 | @rules = []
42 | for name, RuleConstructor of rules
43 | level = @config[name].level
44 | if level in ['error', 'warn']
45 | rule = new RuleConstructor this, @config
46 | if @acceptRule(rule)
47 | @rules.push rule
48 | else if level isnt 'ignore'
49 | throw new Error("unknown level #{level}")
50 |
51 | normalizeResult: (p, result) ->
52 | if result is true
53 | return @createError p.rule.name
54 | if @isObject result
55 | return @createError p.rule.name, result
56 |
--------------------------------------------------------------------------------
/test/test_comment_config.coffee:
--------------------------------------------------------------------------------
1 | path = require 'path'
2 | vows = require 'vows'
3 | assert = require 'assert'
4 | coffeelint = require path.join('..', 'lib', 'coffeelint')
5 |
6 | vows.describe('comment config').addBatch({
7 |
8 | 'Disable statements' :
9 |
10 | topic : () ->
11 | """
12 | # coffeelint: disable=no_trailing_semicolons
13 | a 'you get a semi-colon';
14 | b 'you get a semi-colon';
15 | # coffeelint: enable=no_trailing_semicolons
16 | c 'everybody gets a semi-colon';
17 | """
18 |
19 | 'can disable rules in your config' : (source) ->
20 | config =
21 | no_trailing_semicolons : {level: 'error'}
22 | errors = coffeelint.lint(source, config)
23 | assert.equal(errors.length, 1)
24 |
25 | 'Enable statements' :
26 |
27 | topic : () ->
28 | """
29 | # coffeelint: enable=no_implicit_parens
30 | a 'implicit parens here'
31 | b 'implicit parens', 'also here'
32 | # coffeelint: disable=no_implicit_parens
33 | c 'implicit parens allowed here'
34 | """
35 |
36 | 'can enable rules not in your config' : (source) ->
37 | errors = coffeelint.lint(source)
38 | assert.equal(errors.length, 2)
39 |
40 | 'Enable all statements' :
41 | topic : () ->
42 | """
43 | # coffeelint: disable=no_trailing_semicolons,no_implicit_parens
44 | a 'you get a semi-colon';
45 | b 'you get a semi-colon';
46 | # coffeelint: enable
47 | c 'everybody gets a semi-colon';
48 | """
49 |
50 | 'will re-enable all rules in your config' : (source) ->
51 | config =
52 | no_implicit_parens : {level: 'error'}
53 | no_trailing_semicolons : {level: 'error'}
54 | errors = coffeelint.lint(source, config)
55 | assert.equal(errors.length, 2)
56 |
57 | }).export(module)
58 |
--------------------------------------------------------------------------------
/test/test_line_endings.coffee:
--------------------------------------------------------------------------------
1 | path = require 'path'
2 | vows = require 'vows'
3 | assert = require 'assert'
4 | coffeelint = require path.join('..', 'lib', 'coffeelint')
5 |
6 | vows.describe('line endings').addBatch({
7 |
8 | 'Unix line endings' :
9 |
10 | topic : 'x = 1\ny=2'
11 |
12 | 'are allowed by default' : (source) ->
13 | errors = coffeelint.lint(source)
14 | assert.isEmpty(errors)
15 |
16 | 'can be forbidden' : (source) ->
17 | config = {line_endings : {level:'error', value:'windows'}}
18 | errors = coffeelint.lint(source, config)
19 | assert.isArray(errors)
20 | assert.lengthOf(errors, 1)
21 | error = errors[0]
22 | assert.equal(error.lineNumber, 1)
23 | assert.equal(error.message, 'Line contains incorrect line endings')
24 | assert.equal(error.context, 'Expected windows')
25 | assert.equal(error.rule, 'line_endings')
26 |
27 | 'Windows line endings' :
28 |
29 | topic : 'x = 1\r\ny=2'
30 |
31 | 'are allowed by default' : (source) ->
32 | errors = coffeelint.lint(source)
33 | assert.isEmpty(errors)
34 |
35 | 'can be forbidden' : (source) ->
36 | config = {line_endings : {level:'error', value:'unix'}}
37 | errors = coffeelint.lint(source, config)
38 | assert.isArray(errors)
39 | assert.lengthOf(errors, 1)
40 | error = errors[0]
41 | assert.equal(error.lineNumber, 1)
42 | assert.equal(error.message, 'Line contains incorrect line endings')
43 | assert.equal(error.context, 'Expected unix')
44 | assert.equal(error.rule, 'line_endings')
45 |
46 | 'Unknown line endings' :
47 |
48 | topic : 'x = 1\ny=2'
49 |
50 | 'throw errors' : (source) ->
51 | config =
52 | line_endings : {level: 'error', value: 'osx'}
53 | assert.throws () ->
54 | coffeelint.lint(source, config)
55 |
56 |
57 | }).export(module)
58 |
--------------------------------------------------------------------------------
/src/configfinder.coffee:
--------------------------------------------------------------------------------
1 | ###
2 | Helpers for finding CoffeeLint config in standard locations, similar to how
3 | JSHint does.
4 | ###
5 |
6 | fs = require 'fs'
7 | path = require 'path'
8 |
9 | # Cache for findFile
10 | findFileResults = {}
11 |
12 | # Searches for a file with a specified name starting with 'dir' and going all
13 | # the way up either until it finds the file or hits the root.
14 | findFile = (name, dir) ->
15 | dir = dir or process.cwd()
16 | filename = path.normalize(path.join(dir, name))
17 | return findFileResults[filename] if findFileResults[filename]
18 | parent = path.resolve(dir, "../")
19 | if fs.existsSync(filename)
20 | findFileResults[filename] = filename
21 | else if dir is parent
22 | findFileResults[filename] = null
23 | else
24 | findFile name, parent
25 |
26 | # Possibly find CoffeeLint configuration within a package.json file.
27 | loadNpmConfig = (dir) ->
28 | fp = findFile("package.json", dir)
29 | loadJSON(fp).coffeelintConfig if fp
30 |
31 | # Parse a JSON file gracefully.
32 | loadJSON = (filename) ->
33 | try
34 | JSON.parse(fs.readFileSync(filename).toString())
35 | catch e
36 | console.error "Could not load JSON file '%s': %s", filename, e
37 | null
38 |
39 | # Tries to find a configuration file in either project directory (if file is
40 | # given), as either the package.json's 'coffeelintConfig' property, or a project
41 | # specific 'coffeelint.json' or a global 'coffeelint.json' in the home
42 | # directory.
43 | exports.getConfig = (filename = null) ->
44 | if filename
45 | dir = path.dirname(path.resolve(filename))
46 | npmConfig = loadNpmConfig(dir)
47 | return npmConfig if npmConfig
48 | projConfig = findFile("coffeelint.json", dir)
49 | return loadJSON(projConfig) if projConfig
50 | envs = process.env.HOME or process.env.HOMEPATH or process.env.USERPROFILE
51 | home = path.normalize(path.join(envs, "coffeelint.json"))
52 | if fs.existsSync(home)
53 | console.log 'loaded', home
54 | return loadJSON(home)
55 |
--------------------------------------------------------------------------------
/src/rules/duplicate_key.coffee:
--------------------------------------------------------------------------------
1 |
2 | module.exports = class DuplicateKey
3 |
4 | rule:
5 | # I don't know of any legitimate reason to define duplicate keys in an
6 | # object. It seems to always be a mistake, it's also a syntax error in
7 | # strict mode.
8 | # See http://jslinterrors.com/duplicate-key-a/
9 | name: 'duplicate_key'
10 | level: 'error'
11 | message: 'Duplicate key defined in object or class'
12 | description:
13 | "Prevents defining duplicate keys in object literals and classes"
14 |
15 | tokens: [ 'IDENTIFIER', "{","}" ]
16 |
17 | constructor: ->
18 | @braceScopes = [] # A stack tracking keys defined in nexted scopes.
19 |
20 | lintToken : ([type], tokenApi) ->
21 |
22 | if type in [ "{","}" ]
23 | @lintBrace arguments...
24 | return undefined
25 |
26 | if type is "IDENTIFIER"
27 | @lintIdentifier arguments...
28 |
29 | lintIdentifier : (token, tokenApi) ->
30 | key = token[1]
31 |
32 | # Class names might not be in a scope
33 | return null if not @currentScope?
34 | nextToken = tokenApi.peek(1)
35 |
36 | # Exit if this identifier isn't being assigned. A and B
37 | # are identifiers, but only A should be examined:
38 | # A = B
39 | return null if nextToken[1] isnt ':'
40 | previousToken = tokenApi.peek(-1)
41 |
42 | # Assigning "@something" and "something" are not the same thing
43 | key = "@#{key}" if previousToken[0] == '@'
44 |
45 | # Added a prefix to not interfere with things like "constructor".
46 | key = "identifier-#{key}"
47 | if @currentScope[key]
48 | return true
49 | else
50 | @currentScope[key] = token
51 | null
52 |
53 | lintBrace : (token) ->
54 | if token[0] == '{'
55 | @braceScopes.push @currentScope if @currentScope?
56 | @currentScope = {}
57 | else
58 | @currentScope = @braceScopes.pop()
59 |
60 | return null
61 |
--------------------------------------------------------------------------------
/src/rules/no_unnecessary_double_quotes.coffee:
--------------------------------------------------------------------------------
1 |
2 |
3 | module.exports = class NoUnnecessaryDoubleQuotes
4 |
5 | rule:
6 | name: 'no_unnecessary_double_quotes'
7 | level : 'ignore'
8 | message : 'Unnecessary double quotes are forbidden'
9 | description: '''
10 | This rule prohibits double quotes unless string interpolation is
11 | used or the string contains single quotes.
12 |
13 | # Double quotes are discouraged:
14 | foo = "bar"
15 |
16 | # Unless string interpolation is used:
17 | foo = "#{bar}baz"
18 |
19 | # Or they prevent cumbersome escaping:
20 | foo = "I'm just following the 'rules'"
21 |
22 |
23 | Double quotes are permitted by default.
24 | '''
25 |
26 | tokens: [ 'STRING' ]
27 |
28 | lintToken : (token, tokenApi) ->
29 | tokenValue = token[1]
30 |
31 | stringValue = tokenValue.match(/^\"(.*)\"$/)
32 | return false unless stringValue # no double quotes, all OK
33 |
34 | hasLegalConstructs = @isInterpolated(tokenApi) or
35 | @containsSingleQuote(tokenValue)
36 |
37 | return not hasLegalConstructs
38 |
39 | isInterpolated : (tokenApi) ->
40 | currentIndex = tokenApi.i
41 | isInterpolated = false
42 | lineTokens = tokenApi.tokensByLine[tokenApi.lineNumber]
43 |
44 | # Traverse backwards to find signs that the current string token is
45 | # generated by the coffee rewriter for string interpolation
46 | for i in [1..currentIndex]
47 | token = tokenApi.peek(-i)
48 | tokenName = token[0]
49 |
50 | if tokenName is ')' and token.stringEnd
51 | break # No interpolation, we can quit
52 | else if tokenName is '(' and
53 | token.origin?[1] is "string interpolation"
54 | isInterpolated = true
55 | break
56 |
57 | return isInterpolated
58 |
59 | containsSingleQuote : (tokenValue) ->
60 | return tokenValue.indexOf("'") isnt -1
61 |
--------------------------------------------------------------------------------
/3rd_party_rules.md:
--------------------------------------------------------------------------------
1 | Creating a 3rd party rule
2 | =========================
3 |
4 | If your rule is overly specific or too restrictive it may not be accepted into
5 | the CoffeeLint repo. This doesn't mean you can't have your rule.
6 |
7 | Setup your repo
8 | ---------------
9 |
10 | My personal preference is to not commit compiled Javascript files to a
11 | CoffeeScript repo.
12 |
13 | 1. `npm init`
14 | 2. `npm install --save coffee-script` When it asks about `main` leave it as `index.js`
15 | 3. Create an `index.js` it only needs two lines
16 |
17 | require('coffee-script');
18 | module.exports = require('./your_rule_name.coffee');
19 |
20 | 4. `sudo npm link`: Once you run this CoffeeLint will be able to `require` your module
21 | 5. Build your rule, make sure the file name matches `index.js`'s `require`
22 |
23 | [link]: https://npmjs.org/doc/cli/npm-link.html
24 |
25 | Loading your rule
26 | -----------------
27 |
28 | It's probably best once you get this worked out, to commit a coffeelint.json to
29 | your repo with your rule enabled. Here is an example:
30 |
31 |
32 | {
33 | "your_rule_name": {
34 | "module": "your-rule-name"
35 | }
36 | }
37 |
38 |
39 | * `your_rule_name`: This MUST match the name inside your rule. A few of of the
40 | built in rules are no_plus_plus, no_tabs, and cyclomatic_complexity
41 | * `your-rule-name`: npm's convention is to use dashes. CoffeeLint is going to
42 | run `require('your-rule-name')` to find this rule.
43 |
44 | Publishing your rule
45 | --------------------
46 |
47 | Once you're ready you can publish it as a normal npm package. Remember to
48 | mention in your readme that they will need to `npm install -g your-rule-name`.
49 | If it's not global CoffeeLint won't see it.
50 |
51 | By convention rule authors add the keyword `coffeelintrule` to their npm
52 | `package.json` so custom rules can be found easily. Click
53 | [here](https://npmjs.org/search?q=coffeelintrule) to list all currently available
54 | custom rules on npm.
55 |
56 | Verify Installation
57 | -------------------
58 |
59 | This will verify your development install when you used `sudo npm link` or when
60 | users run `npm install -g your-rule-name`
61 |
62 | Verify your installation using:
63 |
64 | node -p "require('your-rule-name');"
65 |
66 | You should get output similar to
67 |
68 | [Function: YourRuleName]
69 |
--------------------------------------------------------------------------------
/src/rules/arrow_spacing.coffee:
--------------------------------------------------------------------------------
1 |
2 | module.exports = class ArrowSpacing
3 |
4 | rule:
5 | name: 'arrow_spacing'
6 | level : 'ignore'
7 | message : 'Function arrow (->) must be spaced properly'
8 | description: """
9 | This rule checks to see that there is spacing before and after 10 | the arrow operator that declares a function. This rule is disabled 11 | by default.
Note that if arrow_spacing is enabled, and you 12 | pass an empty function as a parameter, arrow_spacing will accept 13 | either a space or no space in-between the arrow operator and the 14 | parenthesis
15 |# Both of this will not trigger an error,
16 | # even with arrow_spacing enabled.
17 | x(-> 3)
18 | x( -> 3)
19 |
20 | # However, this will trigger an error
21 | x((a,b)-> 3)
22 |
23 |
15 | # This semicolon is meaningful.
16 | x = '1234'; console.log(x)
17 |
18 | # This semicolon is redundant.
19 | alert('end of line');
20 |
21 |
22 | Trailing semicolons are forbidden by default.
23 | """
24 |
25 |
26 | lintLine: (line, lineApi) ->
27 |
28 | # The TERMINATOR token is extended through to the next token. As a
29 | # result a line with a comment DOES have a token: the TERMINATOR from
30 | # the last line of code.
31 | lineTokens = lineApi.getLineTokens()
32 | if lineTokens.length is 1 and lineTokens[0][0] in ['TERMINATOR', 'HERECOMMENT']
33 | return
34 |
35 | newLine = line
36 | if lineTokens.length > 1 and lineTokens[lineTokens.length - 1][0] is 'TERMINATOR'
37 |
38 | # startPos contains the end position of the last non-TERMINATOR token
39 | # endPos contains the start position of the TERMINATOR token
40 | # if startPos and endPos arent equal, that probably means a comment
41 | # was sliced out of the tokenizer
42 |
43 | startPos = lineTokens[lineTokens.length - 2][2].last_column + 1
44 | endPos = lineTokens[lineTokens.length - 1][2].first_column
45 | if (startPos isnt endPos)
46 | startCounter = startPos
47 | while line[startCounter] isnt "#" and startCounter < line.length
48 | startCounter++
49 | newLine = line.substring(0, startCounter).replace(/\s*$/, '')
50 |
51 | hasSemicolon = regexes.trailingSemicolon.test(newLine)
52 | [first..., last] = lineTokens
53 | hasNewLine = last and last.newLine?
54 |
55 | # Don't throw errors when the contents of multiline strings,
56 | # regexes and the like end in ";"
57 | if hasSemicolon and not hasNewLine and lineApi.lineHasToken() and
58 | last[0] isnt 'STRING'
59 | return true
60 |
--------------------------------------------------------------------------------
/src/rules/colon_assignment_spacing.coffee:
--------------------------------------------------------------------------------
1 | module.exports = class ColonAssignmentSpacing
2 |
3 | rule :
4 | name : 'colon_assignment_spacing'
5 | level : 'ignore'
6 | message :'Colon assignment without proper spacing'
7 | spacing :
8 | left : 0
9 | right : 0
10 | description : """
11 | This rule checks to see that there is spacing before and 12 | after the colon in a colon assignment (i.e., classes, objects). 13 | The spacing amount is specified by 14 | spacing.left and spacing.right, respectively. 15 | A zero value means no spacing required. 16 |
17 |
18 | #
19 | # If spacing.left and spacing.right is 1
20 | #
21 |
22 | # Good
23 | object = {spacing : true}
24 | class Dog
25 | canBark : true
26 |
27 | # Bad
28 | object = {spacing: true}
29 | class Cat
30 | canBark: false
31 | #
14 | Enabling this option will prevent this ugly
15 | # but otherwise valid CoffeeScript.
16 | twoSpaces = () ->
17 | fourSpaces = () ->
18 | eightSpaces = () ->
19 | 'this is valid CoffeeScript'
20 |
21 |
22 |
23 | Two space indentation is enabled by default.
24 | """
25 |
26 |
27 | tokens: [ 'INDENT', "[", "]" ]
28 |
29 | constructor: ->
30 | @arrayTokens = [] # A stack tracking the array token pairs.
31 |
32 | # Return an error if the given indentation token is not correct.
33 | lintToken: (token, tokenApi) ->
34 | [type, numIndents, lineNumber] = token
35 |
36 | if type in [ "[", "]" ]
37 | @lintArray(token)
38 | return undefined
39 |
40 | return null if token.generated?
41 |
42 | # HACK: CoffeeScript's lexer insert indentation in string
43 | # interpolations that start with spaces e.g. "#{ 123 }"
44 | # so ignore such cases. Are there other times an indentation
45 | # could possibly follow a '+'?
46 | previous = tokenApi.peek(-2)
47 | isInterpIndent = previous and previous[0] == '+'
48 |
49 | # Ignore the indentation inside of an array, so that
50 | # we can allow things like:
51 | # x = ["foo",
52 | # "bar"]
53 | previous = tokenApi.peek(-1)
54 | isArrayIndent = @inArray() and previous?.newLine
55 |
56 | # Ignore indents used to for formatting on multi-line expressions, so
57 | # we can allow things like:
58 | # a = b =
59 | # c = d
60 | previousSymbol = tokenApi.peek(-1)?[0]
61 | isMultiline = previousSymbol in ['=', ',']
62 |
63 | # Summarize the indentation conditions we'd like to ignore
64 | ignoreIndent = isInterpIndent or isArrayIndent or isMultiline
65 |
66 | # Compensate for indentation in function invocations that span multiple
67 | # lines, which can be ignored.
68 | if @isChainedCall tokenApi
69 | { lines, lineNumber } = tokenApi
70 | currentLine = lines[lineNumber]
71 | prevNum = 1
72 |
73 | # keep going back until we are not at a comment or a blank line
74 | prevNum += 1 while (/^\s*(#|$)/.test(lines[lineNumber - prevNum]))
75 | previousLine = lines[lineNumber - prevNum]
76 |
77 | previousIndentation = previousLine.match(/^(\s*)/)[1].length
78 | # I don't know why, but when inside a function, you make a chained
79 | # call and define an inline callback as a parameter, the body of
80 | # that callback gets the indentation reported higher than it really
81 | # is. See issue #88
82 | # NOTE: Adding this line moved the cyclomatic complexity over the
83 | # limit, I'm not sure why
84 | numIndents = currentLine.match(/^(\s*)/)[1].length
85 | numIndents -= previousIndentation
86 |
87 |
88 | # Now check the indentation.
89 | expected = tokenApi.config[@rule.name].value
90 | if not ignoreIndent and numIndents != expected
91 | return {
92 | context: "Expected #{expected} got #{numIndents}"
93 | }
94 | # Return true if the current token is inside of an array.
95 | inArray : () ->
96 | return @arrayTokens.length > 0
97 |
98 | # Lint the given array token.
99 | lintArray : (token) ->
100 | # Track the array token pairs
101 | if token[0] == '['
102 | @arrayTokens.push(token)
103 | else if token[0] == ']'
104 | @arrayTokens.pop()
105 | # Return null, since we're not really linting
106 | # anything here.
107 | null
108 |
109 | # Return true if the current token is part of a property access
110 | # that is split across lines, for example:
111 | # $('body')
112 | # .addClass('foo')
113 | # .removeClass('bar')
114 | isChainedCall: (tokenApi) ->
115 | { tokens, i } = tokenApi
116 | # Get the index of the second most recent new line.
117 | lines = (i for token, i in tokens[..i] when token.newLine?)
118 |
119 | lastNewLineIndex = if lines then lines[lines.length - 2] else null
120 |
121 | # Bail out if there is no such token.
122 | return false if not lastNewLineIndex?
123 |
124 | # Otherwise, figure out if that token or the next is an attribute
125 | # look-up.
126 | tokens = [tokens[lastNewLineIndex], tokens[lastNewLineIndex + 1]]
127 |
128 | return !!(t for t in tokens when t and t[0] == '.').length
129 |
130 |
--------------------------------------------------------------------------------
/test/test_indent.coffee:
--------------------------------------------------------------------------------
1 | path = require 'path'
2 | vows = require 'vows'
3 | assert = require 'assert'
4 | coffeelint = require path.join('..', 'lib', 'coffeelint')
5 |
6 |
7 | vows.describe('indent').addBatch({
8 |
9 | 'Indentation' :
10 |
11 | topic : () ->
12 | """
13 | x = () ->
14 | 'two spaces'
15 |
16 | a = () ->
17 | 'four spaces'
18 | """
19 |
20 | 'defaults to two spaces' : (source) ->
21 | errors = coffeelint.lint(source)
22 | assert.equal(errors.length, 1)
23 | error = errors[0]
24 | msg = 'Line contains inconsistent indentation'
25 | assert.equal(error.message, msg)
26 | assert.equal(error.rule, 'indentation')
27 | assert.equal(error.lineNumber, 5)
28 | assert.equal(error.context, "Expected 2 got 4")
29 |
30 | 'can be overridden' : (source) ->
31 | config =
32 | indentation:
33 | level: 'error'
34 | value: 4
35 | errors = coffeelint.lint(source, config)
36 | assert.equal(errors.length, 1)
37 | error = errors[0]
38 | assert.equal(error.lineNumber, 2)
39 |
40 | 'is optional' : (source) ->
41 | config =
42 | indentation:
43 | level: 'ignore'
44 | value: 4
45 | errors = coffeelint.lint(source, config)
46 | assert.equal(errors.length, 0)
47 |
48 | 'Nested indentation errors' :
49 |
50 | topic : () ->
51 | """
52 | x = () ->
53 | y = () ->
54 | 1234
55 | """
56 |
57 | 'are caught' : (source) ->
58 | errors = coffeelint.lint(source)
59 | assert.lengthOf(errors, 1)
60 | error = errors[0]
61 | assert.equal(error.lineNumber, 3)
62 |
63 | 'Compiler generated indentation' :
64 |
65 | topic : () ->
66 | """
67 | () ->
68 | if 1 then 2 else 3
69 | """
70 |
71 | 'is ignored when not using two spaces' : (source) ->
72 | config =
73 | indentation:
74 | value: 4
75 | errors = coffeelint.lint(source, config)
76 | assert.isEmpty(errors)
77 |
78 | 'Indentation inside interpolation' :
79 |
80 | topic : 'a = "#{ 1234 }"'
81 |
82 | 'is ignored' : (source) ->
83 | errors = coffeelint.lint(source)
84 | assert.isEmpty(errors)
85 |
86 | 'Indentation in multi-line expressions' :
87 |
88 | topic : """
89 | x = '1234' + '1234' + '1234' +
90 | '1234' + '1234'
91 | """
92 |
93 | 'is ignored' : (source) ->
94 | errors = coffeelint.lint(source)
95 | assert.isEmpty(errors)
96 |
97 | 'Indentation across line breaks' :
98 |
99 | topic : () ->
100 | """
101 | days = ["mon", "tues", "wed",
102 | "thurs", "fri"
103 | "sat", "sun"]
104 |
105 | x = myReallyLongFunctionName =
106 | 1234
107 |
108 | arr = [() ->
109 | 1234
110 | ]
111 | """
112 |
113 | 'is ignored' : (source) ->
114 | errors = coffeelint.lint(source)
115 | assert.isEmpty(errors)
116 |
117 | 'Indentation on seperate line invocation' :
118 |
119 | topic : """
120 | rockinRockin
121 | .around ->
122 | 3
123 |
124 | rockrockrock.
125 | around ->
126 | 1234
127 | """
128 |
129 | 'is ignored. Issue #4' : (source) ->
130 | errors = coffeelint.lint(source)
131 | assert.isEmpty(errors)
132 |
133 | 'Indented chained invocations' :
134 |
135 | topic : """
136 | $('body')
137 | .addClass('k')
138 | .removeClass 'k'
139 | .animate()
140 | .hide()
141 | """
142 |
143 | 'is permitted' : (source) ->
144 | assert.isEmpty(coffeelint.lint(source))
145 |
146 | 'Ignore comment in indented chained invocations' :
147 | topic : () ->
148 | """
149 | test()
150 | .r((s) ->
151 | # Ignore this comment
152 | # Ignore this one too
153 | # Ignore this one three
154 | ab()
155 | x()
156 | y()
157 | )
158 | .s()
159 | """
160 | 'no error when comment is in first line of a chain' : (source) ->
161 | config =
162 | indentation:
163 | value: 4
164 | errors = coffeelint.lint(source, config)
165 | assert.isEmpty(errors)
166 |
167 | 'Ignore blank line in indented chained invocations' :
168 | topic : () ->
169 | """
170 | test()
171 | .r((s) ->
172 |
173 |
174 | ab()
175 | x()
176 | y()
177 | )
178 | .s()
179 | """
180 | 'no error when blank line is in first line of a chain' : (source) ->
181 | config =
182 | indentation:
183 | value: 4
184 | errors = coffeelint.lint(source, config)
185 | assert.isEmpty(errors)
186 |
187 | 'Arbitrarily indented arguments' :
188 |
189 | topic : """
190 | myReallyLongFunction withLots,
191 | ofArguments,
192 | everywhere
193 | """
194 |
195 | 'are permitted' : (source) ->
196 | errors = coffeelint.lint(source)
197 | assert.isEmpty(errors)
198 |
199 | 'Indenting a callback in a chained call inside a function':
200 |
201 | topic: """
202 | someFunction = ->
203 | $.when(somePromise)
204 | .done (result) ->
205 | foo = result.bar
206 | """
207 | 'is permitted. See issue #88': (source) ->
208 | errors = coffeelint.lint(source)
209 | assert.isEmpty(errors)
210 |
211 | }).export(module)
212 |
--------------------------------------------------------------------------------
/test/test_cyclomatic_complexity.coffee:
--------------------------------------------------------------------------------
1 | path = require 'path'
2 | vows = require 'vows'
3 | assert = require 'assert'
4 | coffeelint = require path.join('..', 'lib', 'coffeelint')
5 |
6 |
7 | # Return the cyclomatic complexity of a code snippet with one function.
8 | getComplexity = (source) ->
9 | config = {cyclomatic_complexity : {level: 'error', value: 0}}
10 | errors = coffeelint.lint(source, config)
11 | assert.isNotEmpty(errors)
12 | assert.lengthOf(errors, 1)
13 | error = errors[0]
14 | assert.equal(error.rule, 'cyclomatic_complexity')
15 | return error.context
16 |
17 |
18 | vows.describe('cyclomatic complexity').addBatch({
19 |
20 | 'Cyclomatic complexity' :
21 |
22 | topic : """
23 | x = ->
24 | 1 and 2 and 3 and
25 | 4 and 5 and 6 and
26 | 7 and 8 and 9 and
27 | 10 and 11
28 | """
29 |
30 | 'defaults to ignore' : (source) ->
31 | errors = coffeelint.lint(source)
32 | assert.isArray(errors)
33 | assert.isEmpty(errors)
34 |
35 | 'can be enabled' : (source) ->
36 | config = {cyclomatic_complexity : {level: 'error'}}
37 | errors = coffeelint.lint(source, config)
38 | assert.isArray(errors)
39 | assert.lengthOf(errors, 1)
40 | error = errors[0]
41 | assert.equal(error.rule, 'cyclomatic_complexity')
42 | assert.equal(error.context, 11)
43 | assert.equal(error.lineNumber, 1)
44 | assert.equal(error.lineNumberEnd, 5)
45 |
46 | 'can be enabled with configurable complexity' : (source) ->
47 | config = {cyclomatic_complexity : {level: 'error', value: 12}}
48 | errors = coffeelint.lint(source)
49 | assert.isArray(errors)
50 | assert.isEmpty(errors)
51 |
52 | 'An empty function' :
53 |
54 | topic : "x = () -> 1234"
55 |
56 | 'has a complexity of one' : (source) ->
57 | complexity = getComplexity(source)
58 | assert.equal(complexity, 1)
59 |
60 | 'If statement' :
61 |
62 | topic : "x = () -> 2 if $ == true"
63 |
64 | 'increments the complexity' : (source) ->
65 | complexity = getComplexity(source)
66 | assert.equal(complexity, 2)
67 |
68 |
69 | 'If Else statement' :
70 |
71 | topic : 'y = -> if $ then 1 else 3'
72 |
73 | 'increments the complexity' : (source) ->
74 | complexity = getComplexity(source)
75 | assert.equal(complexity, 2)
76 |
77 | 'If ElseIf statement' :
78 |
79 | topic : """
80 | x = ->
81 | if 1233
82 | 'abc'
83 | else if 456
84 | 'xyz'
85 | """
86 |
87 | 'has a complexity of three' : (source) ->
88 | complexity = getComplexity(source)
89 | assert.equal(complexity, 3)
90 |
91 | 'If If-Else Else statement' :
92 |
93 | topic : """
94 | z = () ->
95 | if x
96 | 1
97 | else if y
98 | 2
99 | else
100 | 3
101 | """
102 |
103 | 'has a complexity of three' : (source) ->
104 | complexity = getComplexity(source)
105 | assert.equal(complexity, 3)
106 |
107 | 'Nested if statements' :
108 |
109 | topic : """
110 | z = () ->
111 | if abc?
112 | if other?
113 | 123
114 | """
115 |
116 | 'has a complexity of three' : (source) ->
117 | complexity = getComplexity(source)
118 | assert.equal(complexity, 3)
119 |
120 |
121 | 'A while loop' :
122 |
123 | topic : """
124 | x = () ->
125 | while 1
126 | 'asdf'
127 | """
128 |
129 | 'increments complexity' : (source) ->
130 | complexity = getComplexity(source)
131 | assert.equal(complexity, 2)
132 |
133 | 'An until loop' :
134 |
135 | topic : "x = () -> log 'a' until $?"
136 |
137 | 'increments complexity' : (source) ->
138 | complexity = getComplexity(source)
139 | assert.equal(complexity, 2)
140 |
141 | 'A for loop' :
142 |
143 | topic : """
144 | x = () ->
145 | for i in window
146 | log i
147 | """
148 |
149 | 'increments complexity' : (source) ->
150 | complexity = getComplexity(source)
151 | assert.equal(complexity, 2)
152 |
153 | 'A list comprehension' :
154 |
155 | topic : "x = -> [a for a in window]"
156 |
157 | 'increments complexity' : (source) ->
158 | complexity = getComplexity(source)
159 | assert.equal(complexity, 2)
160 |
161 | 'Try / Catch blocks' :
162 |
163 | topic : """
164 | x = () ->
165 | try
166 | divide("byZero")
167 | catch error
168 | log("uh oh")
169 | """
170 |
171 | 'increments complexity' : (source) ->
172 | assert.equal(getComplexity(source), 2)
173 |
174 | 'Try / Catch / Finally blocks' :
175 |
176 | topic : """
177 | x = () ->
178 | try
179 | divide("byZero")
180 | catch error
181 | log("uh oh")
182 | finally
183 | clean()
184 | """
185 |
186 | 'increments complexity' : (source) ->
187 | assert.equal(getComplexity(source), 2)
188 |
189 | 'Switch statements without an else' :
190 |
191 | topic : '''
192 | x = () ->
193 | switch a
194 | when "b" then "b"
195 | when "c" then "c"
196 | when "d" then "d"
197 | '''
198 |
199 | 'increase complexity by the number of cases' : (source) ->
200 | complexity = getComplexity(source)
201 | assert.equal(complexity, 4)
202 |
203 | 'Switch statements with an else' :
204 |
205 | topic : '''
206 | x = () ->
207 | switch a
208 | when "b" then "b"
209 | when "c" then "c"
210 | when "d" then "d"
211 | else "e"
212 | '''
213 |
214 | 'increase complexity by the number of cases' : (source) ->
215 | complexity = getComplexity(source)
216 | assert.equal(complexity, 4)
217 |
218 | 'And operators' :
219 |
220 | topic : 'x = () -> $ and window'
221 |
222 | 'increments the complexity' : (source) ->
223 | complexity = getComplexity(source)
224 | assert.equal(complexity, 2)
225 |
226 | 'Or operators' :
227 |
228 | topic : 'x = () -> $ or window'
229 |
230 | 'increments the complexity' : (source) ->
231 | complexity = getComplexity(source)
232 | assert.equal(complexity, 2)
233 |
234 | 'A complicated example' :
235 |
236 | topic : """
237 | x = () ->
238 | if a and b and c or d and c or e
239 | if x or d or e of f
240 | 1
241 | else if window
242 | while 1 and 3
243 | 2
244 | while false
245 | y
246 | return false
247 | """
248 |
249 | 'works' : (source) ->
250 | config = {cyclomatic_complexity : {level: 'error'}}
251 | errors = coffeelint.lint(source, config)
252 | assert.isArray(errors)
253 | assert.lengthOf(errors, 1)
254 | error = errors[0]
255 | assert.equal(error.rule, 'cyclomatic_complexity')
256 | assert.equal(error.lineNumber, 1)
257 | assert.equal(error.lineNumberEnd, 10)
258 | assert.equal(error.context, 14)
259 |
260 | }).export(module)
261 |
--------------------------------------------------------------------------------
/test/test_arrows.coffee:
--------------------------------------------------------------------------------
1 | path = require 'path'
2 | vows = require 'vows'
3 | assert = require 'assert'
4 | coffeelint = require path.join('..', 'lib', 'coffeelint')
5 |
6 | vows.describe('arrows').addBatch({
7 |
8 | 'No spacing around the arrow operator' :
9 |
10 | topic : ->
11 | '''
12 | test1 = (foo, bar)->console.log("foobar")
13 | test2 = (foo, bar) ->console.log("foo->bar")
14 | test3 = (foo, bar)-> console.log("foo->bar")
15 | test4 = (foo, bar)->
16 | console.log("foo->bar")
17 | test5 = (foo, bar) ->
18 | console.log("foo->bar")
19 | '''
20 |
21 | 'will return an error' : (source) ->
22 | config = {
23 | "indentation" : { "value": 2, "level": "error" }
24 | "arrow_spacing": { "level": "error"}
25 | }
26 | errors = coffeelint.lint(source, config)
27 | assert.equal(errors.length, 4)
28 | assert.equal(errors[0].lineNumber, 1)
29 | assert.equal(errors[1].lineNumber, 2)
30 | assert.equal(errors[2].lineNumber, 3)
31 | assert.equal(errors[3].lineNumber, 4)
32 |
33 | 'will be ignored (no error)' : (source) ->
34 | config = { "arrow_spacing": { "level": "ignore" } }
35 | errors = coffeelint.lint(source, config)
36 | assert.isEmpty(errors)
37 |
38 | 'Handles good spacing when parentheses are generated' :
39 |
40 | topic : ->
41 | '''
42 | testingThis
43 | .around ->
44 | -> 4
45 |
46 | testingThis
47 | .around ->
48 | 4
49 |
50 | testingThis
51 | .around -> 4
52 |
53 | testingThis =
54 | -> 5
55 |
56 | testingThis.around (a, b) ->
57 | -> "4"
58 |
59 | '''
60 |
61 | 'when spacing is not required around arrow operator' : (source) ->
62 | config = {
63 | "indentation": { "value": 2, "level": "error" },
64 | "arrow_spacing": { "level": "ignore" }
65 | }
66 | errors = coffeelint.lint(source, config)
67 | assert.isEmpty(errors)
68 |
69 | 'when spacing is required around arrow operator' : (source) ->
70 | config = {
71 | "indentation": { "value": 2, "level": "error" },
72 | "arrow_spacing": { "level": "error" }
73 | }
74 | errors = coffeelint.lint(source, config)
75 | assert.isEmpty(errors)
76 |
77 | 'Handles bad spacing when parentheses are generated' :
78 |
79 | topic : ->
80 | '''
81 | testingThis
82 | .around ->
83 | ->4
84 |
85 | testingThis
86 | .around ->4
87 |
88 | testingThis =
89 | ->5
90 |
91 | testingThis.around (a, b) ->
92 | ->"4"
93 |
94 | testingThis ->-> "X"
95 |
96 | testingThis ->->"X"
97 | '''
98 |
99 | 'when spacing is required around arrow operator' : (source) ->
100 | config = { "arrow_spacing": { "level": "error" } }
101 | errors = coffeelint.lint(source, config)
102 | assert.equal(errors[0].lineNumber, 3)
103 | assert.equal(errors[1].lineNumber, 6)
104 | assert.equal(errors[2].lineNumber, 9)
105 | assert.equal(errors[3].lineNumber, 12)
106 | assert.equal(errors[4].lineNumber, 14)
107 | assert.equal(errors[5].lineNumber, 16)
108 | assert.equal(errors[6].lineNumber, 16)
109 | assert.equal(errors.length, 7)
110 |
111 | 'when spacing is not required around arrow operator' : (source) ->
112 | config = { "arrow_spacing": { "level": "ignore" } }
113 | errors = coffeelint.lint(source, config)
114 | assert.isEmpty(errors)
115 |
116 | 'Ignore spacing for non-generated parentheses' :
117 | # if the function has no parameters (and thus no parentheses),
118 | # it will accept a lack of spacing preceding the arrow (first example)
119 | topic : ->
120 | '''
121 | x(-> 3)
122 | x( -> 3)
123 | x((a,b) -> c)
124 | (-> true)()
125 | '''
126 | 'when spacing is required around arrow operator' : (source) ->
127 | config = { "arrow_spacing": { "level": "error" } }
128 | errors = coffeelint.lint(source, config)
129 | assert.equal(errors.length, 0)
130 |
131 | 'when spacing is not required around arrow operator' : (source) ->
132 | config = { "arrow_spacing": { "level": "ignore" } }
133 | errors = coffeelint.lint(source, config)
134 | assert.isEmpty(errors, 0)
135 |
136 | 'Handle an arrow at beginning of statement' :
137 | topic : ->
138 | '''
139 | @waitForSelector ".application",
140 | -> @test.pass "homepage loaded ok"
141 | -> @test.fail "homepage didn't load"
142 | 2000
143 | '''
144 |
145 | 'when spacing is required around arrow operator' : (source) ->
146 | config = { "arrow_spacing": { "level": "error" } }
147 | errors = coffeelint.lint(source, config)
148 | assert.equal(errors.length, 0)
149 |
150 | 'when spacing is not required around arrow operator' : (source) ->
151 | config = { "arrow_spacing": { "level": "ignore" } }
152 | errors = coffeelint.lint(source, config)
153 | assert.isEmpty(errors, 0)
154 |
155 | 'Handle a nested arrow at end of file' :
156 | topic : ->
157 | 'class A\n f: ->'
158 |
159 | 'when spacing is required around arrow operator' : (source) ->
160 | config = { "arrow_spacing": { "level": "error" } }
161 | errors = coffeelint.lint(source, config)
162 | assert.equal(errors.length, 0)
163 |
164 | 'when spacing is not required around arrow operator' : (source) ->
165 | config = { "arrow_spacing": { "level": "ignore" } }
166 | errors = coffeelint.lint(source, config)
167 | assert.isEmpty(errors, 0)
168 |
169 | 'Handle a nested arrow at end of file' :
170 | topic : ->
171 | 'define ->\n class A\n f: ->'
172 |
173 | 'when spacing is required around arrow operator' : (source) ->
174 | config = { "arrow_spacing": { "level": "error" } }
175 | errors = coffeelint.lint(source, config)
176 | assert.equal(errors.length, 0)
177 |
178 | 'when spacing is not required around arrow operator' : (source) ->
179 | config = { "arrow_spacing": { "level": "ignore" } }
180 | errors = coffeelint.lint(source, config)
181 | assert.isEmpty(errors, 0)
182 |
183 | 'Handle an arrow at end of file' :
184 | topic : ->
185 | 'f: ->'
186 |
187 | 'when spacing is required around arrow operator' : (source) ->
188 | config = { "arrow_spacing": { "level": "error" } }
189 | errors = coffeelint.lint(source, config)
190 | assert.equal(errors.length, 0)
191 |
192 | 'when spacing is not required around arrow operator' : (source) ->
193 | config = { "arrow_spacing": { "level": "ignore" } }
194 | errors = coffeelint.lint(source, config)
195 | assert.isEmpty(errors, 0)
196 |
197 | 'Handle an arrow at end of file' :
198 | topic : ->
199 | '{f: ->}'
200 |
201 | 'when spacing is required around arrow operator' : (source) ->
202 | config = { "arrow_spacing": { "level": "error" } }
203 | errors = coffeelint.lint(source, config)
204 | assert.equal(errors.length, 1)
205 |
206 | 'when spacing is not required around arrow operator' : (source) ->
207 | config = { "arrow_spacing": { "level": "ignore" } }
208 | errors = coffeelint.lint(source, config)
209 | assert.isEmpty(errors, 0)
210 |
211 | }).export(module)
212 |
--------------------------------------------------------------------------------
/src/coffeelint.coffee:
--------------------------------------------------------------------------------
1 | ###
2 | CoffeeLint
3 |
4 | Copyright (c) 2011 Matthew Perpick.
5 | CoffeeLint is freely distributable under the MIT license.
6 | ###
7 |
8 |
9 | # Coffeelint's namespace.
10 | # Browserify wrapps this file in a UMD that will set window.coffeelint to
11 | # exports
12 | coffeelint = exports
13 |
14 | if window?
15 | # If we're in the browser assume CoffeeScript is already loaded.
16 | CoffeeScript = window.CoffeeScript
17 | else
18 | # By storing this in a variable it prevents browserify from finding this
19 | # dependency. If it isn't hidden there is an error attempting to inline
20 | # CoffeeScript. if browserify uses `-i` to ignore the dependency it
21 | # creates an empty shim which breaks NodeJS
22 | # https://github.com/substack/node-browserify/issues/471
23 | cs = 'coffee-script'
24 | CoffeeScript = require cs
25 |
26 | # Browserify will inline the file at compile time.
27 | packageJSON = require('./../package.json')
28 |
29 | # The current version of Coffeelint.
30 | coffeelint.VERSION = packageJSON.version
31 |
32 |
33 | # CoffeeLint error levels.
34 | ERROR = 'error'
35 | WARN = 'warn'
36 | IGNORE = 'ignore'
37 |
38 | coffeelint.RULES = RULES = require './rules.coffee'
39 |
40 | # Patch the source properties onto the destination.
41 | extend = (destination, sources...) ->
42 | for source in sources
43 | (destination[k] = v for k, v of source)
44 | return destination
45 |
46 | # Patch any missing attributes from defaults to source.
47 | defaults = (source, defaults) ->
48 | extend({}, defaults, source)
49 |
50 | # Helper to remove rules from disabled list
51 | difference = (a, b) ->
52 | j = 0
53 | while j < a.length
54 | if a[j] in b
55 | a.splice(j, 1)
56 | else
57 | j++
58 |
59 | LineLinter = require './line_linter.coffee'
60 | LexicalLinter = require './lexical_linter.coffee'
61 | ASTLinter = require './ast_linter.coffee'
62 |
63 | # Merge default and user configuration.
64 | mergeDefaultConfig = (userConfig) ->
65 | config = {}
66 | for rule, ruleConfig of RULES
67 | config[rule] = defaults(userConfig[rule], ruleConfig)
68 |
69 |
70 | return config
71 |
72 | coffeelint.invertLiterate = (source) ->
73 | source = CoffeeScript.helpers.invertLiterate source
74 | # Strip the first 4 spaces from every line. After this the markdown is
75 | # commented and all of the other code should be at their natural location.
76 | newSource = ""
77 | for line in source.split "\n"
78 | if line.match(/^#/)
79 | # strip trailing space
80 | line = line.replace /\s*$/, ''
81 | # Strip the first 4 spaces of every line. This is how Markdown
82 | # indicates code, so in the end this pulls everything back to where it
83 | # would be indented if it hadn't been written in literate style.
84 | line = line.replace /^\s{4}/g, ''
85 | newSource += "#{line}\n"
86 |
87 | newSource
88 |
89 | _rules = {}
90 | coffeelint.registerRule = (RuleConstructor, ruleName = undefined) ->
91 | p = new RuleConstructor
92 |
93 | name = p?.rule?.name or "(unknown)"
94 | e = (msg) -> throw new Error "Invalid rule: #{name} #{msg}"
95 | unless p.rule?
96 | e "Rules must provide rule attribute with a default configuration."
97 |
98 | e "Rule defaults require a name" unless p.rule.name?
99 |
100 | if ruleName? and ruleName isnt p.rule.name
101 | e "Mismatched rule name: #{ruleName}"
102 |
103 | e "Rule defaults require a message" unless p.rule.message?
104 | e "Rule defaults require a description" unless p.rule.description?
105 | unless p.rule.level in [ 'ignore', 'warn', 'error' ]
106 | e "Default level must be 'ignore', 'warn', or 'error'"
107 |
108 | if typeof p.lintToken is 'function'
109 | e "'tokens' is required for 'lintToken'" unless p.tokens
110 | else if typeof p.lintLine isnt 'function' and
111 | typeof p.lintAST isnt 'function'
112 | e "Rules must implement lintToken, lintLine, or lintAST"
113 |
114 | # Capture the default options for the new rule.
115 | RULES[p.rule.name] = p.rule
116 | _rules[p.rule.name] = RuleConstructor
117 |
118 | # These all need to be explicitly listed so they get picked up by browserify.
119 | coffeelint.registerRule require './rules/arrow_spacing.coffee'
120 | coffeelint.registerRule require './rules/no_tabs.coffee'
121 | coffeelint.registerRule require './rules/no_trailing_whitespace.coffee'
122 | coffeelint.registerRule require './rules/max_line_length.coffee'
123 | coffeelint.registerRule require './rules/line_endings.coffee'
124 | coffeelint.registerRule require './rules/no_trailing_semicolons.coffee'
125 | coffeelint.registerRule require './rules/indentation.coffee'
126 | coffeelint.registerRule require './rules/camel_case_classes.coffee'
127 | coffeelint.registerRule require './rules/colon_assignment_spacing.coffee'
128 | coffeelint.registerRule require './rules/no_implicit_braces.coffee'
129 | coffeelint.registerRule require './rules/no_plusplus.coffee'
130 | coffeelint.registerRule require './rules/no_throwing_strings.coffee'
131 | coffeelint.registerRule require './rules/no_backticks.coffee'
132 | coffeelint.registerRule require './rules/no_implicit_parens.coffee'
133 | coffeelint.registerRule require './rules/no_empty_param_list.coffee'
134 | coffeelint.registerRule require './rules/no_stand_alone_at.coffee'
135 | coffeelint.registerRule require './rules/space_operators.coffee'
136 | coffeelint.registerRule require './rules/duplicate_key.coffee'
137 | coffeelint.registerRule require './rules/empty_constructor_needs_parens.coffee'
138 | coffeelint.registerRule require './rules/cyclomatic_complexity.coffee'
139 | coffeelint.registerRule require './rules/newlines_after_classes.coffee'
140 | coffeelint.registerRule require './rules/no_unnecessary_fat_arrows.coffee'
141 | coffeelint.registerRule require './rules/missing_fat_arrows.coffee'
142 | coffeelint.registerRule(
143 | require './rules/non_empty_constructor_needs_parens.coffee'
144 | )
145 | coffeelint.registerRule require './rules/no_unnecessary_double_quotes.coffee'
146 | coffeelint.registerRule require './rules/no_debugger.coffee'
147 | coffeelint.registerRule(
148 | require './rules/no_interpolation_in_single_quotes.coffee'
149 | )
150 |
151 | hasSyntaxError = (source) ->
152 | try
153 | # If there are syntax errors this will abort the lexical and line
154 | # linters.
155 | CoffeeScript.tokens(source)
156 | return false
157 | return true
158 |
159 | # Check the source against the given configuration and return an array
160 | # of any errors found. An error is an object with the following
161 | # properties:
162 | #
163 | # {
164 | # rule : 'Name of the violated rule',
165 | # lineNumber: 'Number of the line that caused the violation',
166 | # level: 'The error level of the violated rule',
167 | # message: 'Information about the violated rule',
168 | # context: 'Optional details about why the rule was violated'
169 | # }
170 | #
171 | coffeelint.lint = (source, userConfig = {}, literate = false) ->
172 | source = @invertLiterate source if literate
173 |
174 | config = mergeDefaultConfig(userConfig)
175 |
176 | # Check ahead for inline enabled rules
177 | disabled_initially = []
178 | for l in source.split('\n')
179 | s = LineLinter.configStatement.exec(l)
180 | if s?.length > 2 and 'enable' in s
181 | for r in s[1..]
182 | unless r in ['enable','disable']
183 | unless r of config and config[r].level in ['warn','error']
184 | disabled_initially.push r
185 | config[r] = { level: 'error' }
186 |
187 | # Do AST linting first so all compile errors are caught.
188 | astErrors = new ASTLinter(source, config, _rules, CoffeeScript).lint()
189 | errors = [].concat(astErrors)
190 |
191 | # only do further checks if the syntax is okay, otherwise they just fail
192 | # with syntax error exceptions
193 | unless hasSyntaxError(source)
194 | # Do lexical linting.
195 | lexicalLinter = new LexicalLinter(source, config, _rules, CoffeeScript)
196 | lexErrors = lexicalLinter.lint()
197 | errors = errors.concat(lexErrors)
198 |
199 | # Do line linting.
200 | tokensByLine = lexicalLinter.tokensByLine
201 | lineLinter = new LineLinter(source, config, _rules, tokensByLine,
202 | literate)
203 | lineErrors = lineLinter.lint()
204 | errors = errors.concat(lineErrors)
205 | block_config = lineLinter.block_config
206 | else
207 | # default this so it knows what to do
208 | block_config =
209 | enable : {}
210 | disable : {}
211 |
212 | # Sort by line number and return.
213 | errors.sort((a, b) -> a.lineNumber - b.lineNumber)
214 |
215 | # Disable/enable rules for inline blocks
216 | all_errors = errors
217 | errors = []
218 | disabled = disabled_initially
219 | next_line = 0
220 | for i in [0...source.split('\n').length]
221 | for cmd of block_config
222 | rules = block_config[cmd][i]
223 | {
224 | 'disable': ->
225 | disabled = disabled.concat(rules)
226 | 'enable': ->
227 | difference(disabled, rules)
228 | disabled = disabled_initially if rules.length is 0
229 | }[cmd]() if rules?
230 | # advance line and append relevant messages
231 | while next_line is i and all_errors.length > 0
232 | next_line = all_errors[0].lineNumber - 1
233 | e = all_errors[0]
234 | if e.lineNumber is i + 1 or not e.lineNumber?
235 | e = all_errors.shift()
236 | errors.push e unless e.rule in disabled
237 |
238 | errors
239 |
--------------------------------------------------------------------------------
/src/coffeelint-schema.json:
--------------------------------------------------------------------------------
1 | {
2 | "title": "JSON schema for coffeelint.json files",
3 | "$schema": "http://json-schema.org/draft-04/schema#",
4 | "definitions": {
5 | "level": {
6 | "description": "Determines the error level",
7 | "type": "string",
8 | "enum": [ "warn", "error", "ignore" ]
9 | },
10 | "coffeelint": {
11 | "type": "object",
12 | "additionalProperties": true,
13 | "properties": {
14 | "arrow_spacing": {
15 | "description": "This rule checks to see that there is spacing before and after the arrow operator that declares a function.",
16 | "type": "object",
17 | "properties": {
18 | "level": {
19 | "$ref": "#/definitions/level"
20 | }
21 | }
22 | },
23 | "camel_case_classes": {
24 | "description": "This rule mandates that all class names are CamelCased. Camel casing class names is a generally accepted way of distinguishing constructor functions - which require the 'new' prefix to behave properly - from plain old functions.",
25 | "type": "object",
26 | "properties": {
27 | "level": {
28 | "$ref": "#/definitions/level"
29 | }
30 | }
31 | },
32 | "coffeescript_error": {
33 | "type": "object",
34 | "properties": {
35 | "level": {
36 | "$ref": "#/definitions/level"
37 | }
38 | }
39 | },
40 | "colon_assignment_spacing": {
41 | "description": "This rule checks to see that there is spacing before and after the colon in a colon assignment (i.e., classes, objects).",
42 | "type": "object",
43 | "properties": {
44 | "level": {
45 | "$ref": "#/definitions/level"
46 | },
47 | "spacing": {
48 | "type": "object",
49 | "properties": {
50 | "left": {
51 | "type": "integer",
52 | "enum": [0, 1]
53 | },
54 | "right": {
55 | "type": "integer",
56 | "enum": [0, 1]
57 | }
58 | }
59 | }
60 | }
61 | },
62 | "cyclomatic_complexity": {
63 | "description": "Examine the complexity of your application.",
64 | "type": "object",
65 | "properties": {
66 | "level": {
67 | "$ref": "#/definitions/level"
68 | },
69 | "value": {
70 | "type": "integer"
71 | }
72 | }
73 | },
74 | "duplicate_key": {
75 | "description": "Prevents defining duplicate keys in object literals and classes.",
76 | "type": "object",
77 | "properties": {
78 | "level": {
79 | "$ref": "#/definitions/level"
80 | }
81 | }
82 | },
83 | "empty_constructor_needs_parens": {
84 | "description": "Requires constructors with no parameters to include the parens.",
85 | "type": "object",
86 | "properties": {
87 | "level": {
88 | "$ref": "#/definitions/level"
89 | }
90 | }
91 | },
92 | "indentation": {
93 | "description": " This rule imposes a standard number of spaces to be used for indentation. Since whitespace is significant in CoffeeScript, it's critical that a project chooses a standard indentation format and stays consistent. Other roads lead to darkness.",
94 | "type": "object",
95 | "properties": {
96 | "level": {
97 | "$ref": "#/definitions/level"
98 | },
99 | "value": {
100 | "type": "integer",
101 | "enum": [2, 4]
102 | }
103 | }
104 | },
105 | "line_endings": {
106 | "description": "This rule ensures your project uses only windows or unix line endings.",
107 | "type": "object",
108 | "properties": {
109 | "level": {
110 | "$ref": "#/definitions/level"
111 | },
112 | "value": {
113 | "type": "string",
114 | "enum": [ "unix", "windows" ]
115 | }
116 | }
117 | },
118 | "max_line_length": {
119 | "description": "This rule imposes a maximum line length on your code.",
120 | "type": "object",
121 | "properties": {
122 | "level": {
123 | "$ref": "#/definitions/level"
124 | },
125 | "value": {
126 | "type": "integer"
127 | },
128 | "limitComments": {
129 | "type": "boolean"
130 | }
131 | }
132 | },
133 | "missing_fat_arrows": {
134 | "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).",
135 | "type": "object",
136 | "properties": {
137 | "level": {
138 | "$ref": "#/definitions/level"
139 | }
140 | }
141 | },
142 | "newlines_after_classes": {
143 | "description": "Checks the number of newlines between classes and other code.",
144 | "type": "object",
145 | "properties": {
146 | "level": {
147 | "$ref": "#/definitions/level"
148 | },
149 | "value": {
150 | "type": "integer",
151 | "enum": [0, 1, 2]
152 | }
153 | }
154 | },
155 | "no_backticks": {
156 | "description": "Backticks allow snippets of JavaScript to be embedded in CoffeeScript. While some folks consider backticks useful in a few niche circumstances, they should be avoided because so none of JavaScript's \"bad parts\", like with and eval, sneak into CoffeeScript.",
157 | "type": "object",
158 | "properties": {
159 | "level": {
160 | "$ref": "#/definitions/level"
161 | }
162 | }
163 | },
164 | "no_debugger": {
165 | "description": "This rule detects the `debugger` statement.",
166 | "type": "object",
167 | "properties": {
168 | "level": {
169 | "$ref": "#/definitions/level"
170 | }
171 | }
172 | },
173 | "no_empty_param_list": {
174 | "description": "This rule prohibits empty parameter lists in function definitions.",
175 | "type": "object",
176 | "properties": {
177 | "level": {
178 | "$ref": "#/definitions/level"
179 | }
180 | }
181 | },
182 | "no_implicit_braces": {
183 | "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.",
184 | "type": "object",
185 | "properties": {
186 | "level": {
187 | "$ref": "#/definitions/level"
188 | },
189 | "strict": {
190 | "type": "boolean"
191 | }
192 | }
193 | },
194 | "no_implicit_parens": {
195 | "description": "This rule prohibits implicit parens on function calls.",
196 | "type": "object",
197 | "properties": {
198 | "level": {
199 | "$ref": "#/definitions/level"
200 | }
201 | }
202 | },
203 | "no_interpolation_in_single_quotes": {
204 | "description": "This rule prohibits string interpolation in a single quoted string.",
205 | "type": "object",
206 | "properties": {
207 | "level": {
208 | "$ref": "#/definitions/level"
209 | }
210 | }
211 | },
212 | "no_plusplus": {
213 | "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.",
214 | "type": "object",
215 | "properties": {
216 | "level": {
217 | "$ref": "#/definitions/level"
218 | }
219 | }
220 | },
221 | "no_stand_alone_at": {
222 | "description": "This rule checks that no stand alone @ are in use, they are discouraged.",
223 | "type": "object",
224 | "properties": {
225 | "level": {
226 | "$ref": "#/definitions/level"
227 | }
228 | }
229 | },
230 | "no_tabs": {
231 | "description": "This rule forbids tabs in indentation. Enough said.",
232 | "type": "object",
233 | "properties": {
234 | "level": {
235 | "$ref": "#/definitions/level"
236 | }
237 | }
238 | },
239 | "no_throwing_strings": {
240 | "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.",
241 | "type": "object",
242 | "properties": {
243 | "level": {
244 | "$ref": "#/definitions/level"
245 | }
246 | }
247 | },
248 | "no_trailing_semicolons": {
249 | "description": "This rule prohibits trailing semicolons, since they are needless cruft in CoffeeScript.",
250 | "type": "object",
251 | "properties": {
252 | "level": {
253 | "$ref": "#/definitions/level"
254 | }
255 | }
256 | },
257 | "no_trailing_whitespace": {
258 | "description": "This rule forbids trailing whitespace in your code, since it is needless cruft.",
259 | "type": "object",
260 | "properties": {
261 | "level": {
262 | "$ref": "#/definitions/level"
263 | },
264 | "allowed_in_comments": {
265 | "type": "boolean"
266 | },
267 | "allowed_in_empty_lines": {
268 | "type": "boolean"
269 | }
270 | }
271 | },
272 | "no_unnecessary_double_quotes": {
273 | "description": "This rule prohibits double quotes unless string interpolation is used or the string contains single quotes.",
274 | "type": "object",
275 | "properties": {
276 | "level": {
277 | "$ref": "#/definitions/level"
278 | }
279 | }
280 | },
281 | "no_unnecessary_fat_arrows": {
282 | "description": "Disallows defining functions with fat arrows when `this` is not used within the function. ",
283 | "type": "object",
284 | "properties": {
285 | "level": {
286 | "$ref": "#/definitions/level"
287 | }
288 | }
289 | },
290 | "non_empty_constructor_needs_parens": {
291 | "description": "Requires constructors with parameters to include the parens.",
292 | "type": "object",
293 | "properties": {
294 | "level": {
295 | "$ref": "#/definitions/level"
296 | }
297 | }
298 | },
299 | "space_operators": {
300 | "description": "This rule enforces that operators have space around them. ",
301 | "type": "object",
302 | "properties": {
303 | "level": {
304 | "$ref": "#/definitions/level"
305 | }
306 | }
307 | }
308 | }
309 | }
310 | },
311 |
312 | "oneOf": [ { "$ref": "#/definitions/coffeelint" } ],
313 | "type": "object"
314 | }
--------------------------------------------------------------------------------
/test/test_commandline.coffee:
--------------------------------------------------------------------------------
1 | #
2 | # Tests for the command line tool.
3 | #
4 |
5 | path = require 'path'
6 | fs = require 'fs'
7 | vows = require 'vows'
8 | assert = require 'assert'
9 | {spawn, exec} = require 'child_process'
10 | coffeelint = require path.join('..', 'lib', 'coffeelint')
11 |
12 |
13 | # The path to the command line tool.
14 | coffeelintPath = path.join('bin', 'coffeelint')
15 |
16 | # Run the coffeelint command line with the given
17 | # args. Callback will be called with (error, stdout,
18 | # stderr)
19 | commandline = (args, callback) ->
20 | exec("#{coffeelintPath} #{args.join(" ")}", callback)
21 |
22 |
23 | process.env.HOME = ""
24 | process.env.HOMEPATH = ""
25 | process.env.USERPROFILE = ""
26 | process.env.COFFEELINT_CONFIG = ""
27 |
28 | # Custom rules are loaded by module name. Using a relative path in the test is
29 | # an unrealistic example when rules can be installed with `npm install -g
30 | # some-custom-rule`. This will setup a fake version of node_modules to a
31 | # relative path doesn't have to be used.
32 | process.env.NODE_PATH += ":" + path.resolve( __dirname,
33 | "fixtures/mock_node_modules/")
34 |
35 | vows.describe('commandline').addBatch({
36 |
37 | 'with no args' :
38 |
39 | topic : () ->
40 | commandline [], this.callback
41 | return undefined
42 |
43 | 'shows usage' : (error, stdout, stderr) ->
44 | assert.isNotNull(error)
45 | assert.notEqual(error.code, 0)
46 | assert.include(stderr, "Usage")
47 | assert.isEmpty(stdout)
48 |
49 | 'version' :
50 | topic : () ->
51 | commandline ["--version"], this.callback
52 | return undefined
53 |
54 | 'exists' : (error, stdout, stderr) ->
55 | assert.isNull(error)
56 | assert.isEmpty(stderr)
57 | assert.isString(stdout)
58 | assert.include(stdout, coffeelint.VERSION)
59 |
60 | 'with clean source' :
61 |
62 | topic : () ->
63 | args = [
64 | '--noconfig'
65 | 'test/fixtures/clean.coffee'
66 | ]
67 | commandline args, this.callback
68 | return undefined
69 |
70 | 'passes' : (error, stdout, stderr) ->
71 | assert.isNull(error)
72 | assert.include(stdout, '0 errors and 0 warnings')
73 | assert.isEmpty(stderr)
74 |
75 | 'with failing source' :
76 |
77 | topic : () ->
78 | args = [
79 | '--noconfig'
80 | 'test/fixtures/fourspaces.coffee'
81 | ]
82 | commandline args, this.callback
83 | return undefined
84 |
85 | 'works' : (error, stdout, stderr) ->
86 | assert.isNotNull(error)
87 | assert.include(stdout.toLowerCase(), 'line')
88 |
89 | 'with findconfig and local coffeelint.json' :
90 |
91 | topic : () ->
92 | args = [
93 | 'test/fixtures/findconfigtest/sevenspaces.coffee'
94 | ]
95 | commandline args, this.callback
96 | return undefined
97 |
98 | 'works' : (error, stdout, stderr) ->
99 | assert.isNull(error)
100 |
101 | 'with findconfig and local package.json' :
102 |
103 | topic : () ->
104 | args = [
105 | 'test/fixtures/findconfigtest/package/sixspaces.coffee'
106 | ]
107 | commandline args, this.callback
108 | return undefined
109 |
110 | 'works' : (error, stdout, stderr) ->
111 | assert.isNull(error)
112 |
113 | 'with custom configuration' :
114 |
115 | topic : () ->
116 | args = [
117 | '-f'
118 | 'test/fixtures/fourspaces.json'
119 | 'test/fixtures/fourspaces.coffee'
120 | ]
121 |
122 | commandline args, this.callback
123 | return undefined
124 |
125 | 'works' : (error, stdout, stderr) ->
126 | assert.isNull(error)
127 |
128 | 'with --rule parameter for a custom plugin':
129 | topic : () ->
130 | args = [
131 | '--rules'
132 | # It's up to NodeJS to resolve the actual path. The top of the
133 | # file modifies NODE_PATH so this can look like a 3rd party
134 | # module.
135 | "he_who_must_not_be_named"
136 | 'test/fixtures/custom_rules/voldemort.coffee'
137 | ]
138 |
139 | commandline args, this.callback
140 | return undefined
141 |
142 | 'works' : (error, stdout, stderr) ->
143 | assert.isNotNull(error)
144 | assert.include(stdout.toLowerCase(), 'forbidden variable name')
145 |
146 | 'with `module` specified for a specific rule':
147 | topic : () ->
148 | args = [
149 | '-f'
150 | 'test/fixtures/custom_rules/rule_module.json'
151 | 'test/fixtures/custom_rules/voldemort.coffee'
152 | ]
153 |
154 | commandline args, this.callback
155 | return undefined
156 |
157 | 'works' : (error, stdout, stderr) ->
158 | assert.isNotNull(error)
159 | assert.include(stdout.toLowerCase(), 'forbidden variable name')
160 |
161 | 'with multiple sources' :
162 |
163 | topic : () ->
164 | args = [
165 | '--noconfig'
166 | '-f'
167 | 'test/fixtures/fourspaces.json'
168 | 'test/fixtures/fourspaces.coffee'
169 | 'test/fixtures/clean.coffee'
170 | ]
171 |
172 | commandline args, this.callback
173 | return undefined
174 |
175 | 'works' : (error, stdout, stderr) ->
176 | assert.isNotNull(error)
177 |
178 | 'with configuration file' :
179 |
180 | topic : () ->
181 | configPath = 'generated_coffeelint.json'
182 | configFile = fs.openSync configPath, 'w'
183 | commandline ['--makeconfig'], (error, stdout, stderr) =>
184 | fs.writeSync configFile, stdout
185 | assert.isNull(error)
186 | args = [
187 | '-f'
188 | configPath
189 | 'test/fixtures/clean.coffee'
190 | ]
191 | commandline args, (args...) =>
192 | this.callback stdout, args...
193 |
194 | return undefined
195 |
196 | 'works' : (config, error, stdout, stderr) ->
197 | assert.isNotNull(config)
198 | # This will throw an exception if it doesn't parse.
199 | JSON.parse config
200 | assert.isNotNull(stdout)
201 | assert.isNull(error)
202 |
203 | 'does not fail on warnings' :
204 |
205 | topic : () ->
206 | args = [
207 | '-f'
208 | 'test/fixtures/twospaces.warning.json'
209 | 'test/fixtures/fourspaces.coffee'
210 | ]
211 |
212 | commandline args, this.callback
213 | return undefined
214 |
215 | 'works' : (error, stdout, stderr) ->
216 | assert.isNull(error)
217 |
218 | 'with broken source' :
219 |
220 | topic : () ->
221 | args = [
222 | '--noconfig'
223 | 'test/fixtures/syntax_error.coffee'
224 | ]
225 | commandline args, this.callback
226 | return undefined
227 |
228 | 'fails' : (error, stdout, stderr) ->
229 | assert.isNotNull(error)
230 |
231 | 'recurses subdirectories' :
232 |
233 | topic : () ->
234 | args = [
235 | '--noconfig',
236 | '-r',
237 | 'test/fixtures/clean.coffee',
238 | 'test/fixtures/subdir'
239 | ]
240 | commandline args, this.callback
241 | return undefined
242 |
243 | 'and reports errors' : (error, stdout, stderr) ->
244 | assert.isNotNull(error, "returned err")
245 | assert.include(stdout.toLowerCase(), 'line')
246 |
247 | 'allows JSLint XML reporting' :
248 |
249 | # FIXME: Not sure how to unit test escaping w/o major refactoring
250 | topic : () ->
251 | args = [
252 | '-f'
253 | 'coffeelint.json'
254 | 'test/fixtures/cyclo_fail.coffee'
255 | '--jslint'
256 | ]
257 | commandline args, this.callback
258 | return undefined
259 |
260 | 'Handles cyclomatic complexity check' : (error, stdout, stderr) ->
261 | assert.include(stdout.toLowerCase(), 'cyclomatic complexity')
262 |
263 | 'using stdin':
264 |
265 | 'with working string':
266 | topic: () ->
267 | exec("echo y = 1 | #{coffeelintPath} --noconfig --stdin",
268 | this.callback)
269 | return undefined
270 |
271 | 'passes': (error, stdout, stderr) ->
272 | assert.isNull(error)
273 | assert.isEmpty(stderr)
274 | assert.isString(stdout)
275 | assert.include(stdout, '0 errors and 0 warnings')
276 |
277 | 'with failing string due to whitespace':
278 | topic: () ->
279 | exec("echo 'x = 1 '| #{coffeelintPath} --noconfig --stdin",
280 | this.callback)
281 | return undefined
282 |
283 | 'fails': (error, stdout, stderr) ->
284 | assert.isNotNull(error)
285 | assert.include(stdout.toLowerCase(), 'trailing whitespace')
286 |
287 | 'literate coffeescript':
288 |
289 | 'with working string':
290 | topic: () ->
291 | exec("echo 'This is Markdown\n\n y = 1' | " +
292 | "#{coffeelintPath} --noconfig --stdin --literate",
293 | this.callback)
294 | return undefined
295 |
296 | 'passes': (error, stdout, stderr) ->
297 | assert.isNull(error)
298 | assert.isEmpty(stderr)
299 | assert.isString(stdout)
300 | assert.include(stdout, '0 errors and 0 warnings')
301 |
302 | 'with failing string due to whitespace':
303 | topic: () ->
304 | exec("echo 'This is Markdown\n\n x = 1 \n y=2'| " +
305 | "#{coffeelintPath} --noconfig --stdin --literate",
306 | this.callback)
307 | return undefined
308 |
309 | 'fails': (error, stdout, stderr) ->
310 | assert.isNotNull(error)
311 | assert.include(stdout.toLowerCase(), 'trailing whitespace')
312 |
313 | 'using environment config file':
314 |
315 | 'with non existing enviroment set config file':
316 | topic: () ->
317 | args = [
318 | 'test/fixtures/clean.coffee'
319 | ]
320 | process.env.COFFEELINT_CONFIG = "not_existing_293ujff"
321 | commandline args, this.callback
322 | return undefined
323 |
324 | 'passes': (error, stdout, stderr) ->
325 | assert.isNull(error)
326 |
327 | 'with existing enviroment set config file':
328 | topic: () ->
329 | args = [
330 | 'test/fixtures/fourspaces.coffee'
331 | ]
332 | conf = "test/fixtures/fourspaces.json"
333 | process.env.COFFEELINT_CONFIG = conf
334 | commandline args, this.callback
335 | return undefined
336 |
337 | 'passes': (error, stdout, stderr) ->
338 | assert.isNull(error)
339 |
340 | 'with existing enviroment set config file + --noconfig':
341 | topic: () ->
342 | args = [
343 | '--noconfig'
344 | 'test/fixtures/fourspaces.coffee'
345 | ]
346 | conf = "test/fixtures/fourspaces.json"
347 | process.env.COFFEELINT_CONFIG = conf
348 | commandline args, this.callback
349 | return undefined
350 |
351 | 'fails': (error, stdout, stderr) ->
352 | assert.isNotNull(error)
353 |
354 | 'reports using basic reporter':
355 | 'with option q set':
356 | 'and no errors occured':
357 | topic: () ->
358 | args = [ '-q', '--noconfig', 'test/fixtures/clean.coffee' ]
359 | commandline args, this.callback
360 | return undefined
361 |
362 | 'no output': (err, stdout, stderr) ->
363 | assert.isEmpty(stdout)
364 |
365 | 'and errors occured':
366 | topic: () ->
367 | args = [ '-q', 'test/fixtures/syntax_error.coffee' ]
368 | commandline args, this.callback
369 | return undefined
370 |
371 | 'output': (error, stdout, stderr) ->
372 | assert.isNotEmpty(stdout)
373 |
374 | 'with option q not set':
375 | 'and no errors occured':
376 | topic: () ->
377 | args = [ 'test/fixtures/clean.coffee' ]
378 | commandline args, this.callback
379 | return undefined
380 |
381 | 'output': (err, stdout, stderr) ->
382 | assert.isNotEmpty(stdout)
383 |
384 | 'and errors occured':
385 | topic: () ->
386 | args = [ 'test/fixtures/syntax_error.coffee' ]
387 | commandline args, this.callback
388 | return undefined
389 |
390 | 'output': (error, stdout, stderr) ->
391 | assert.isNotEmpty(stdout)
392 |
393 | }).export(module)
394 |
--------------------------------------------------------------------------------