coffeelint 0.0.6 → 0.1.2

checksums.yaml

@@ -1,15 +1,7 @@
----
-!binary "U0hBMQ==":
-  metadata.gz: !binary |-
-    NWNhOWRlOGVkMDhkMTQwMjFkMTRhYjMwZTQxMTE2MGQxOTkxZjFlMA==
-  data.tar.gz: !binary |-
-    NTVlMzA1ZTk2OGU5NDNiY2U2YTU3OTc0MTEyMzcyYTAwZDRhZTMxMQ==
-!binary "U0hBNTEy":
-  metadata.gz: !binary |-
-    YjBmNzVkZjRmMGJlOTRhOWRjMzJjNTJjZWU4MTE4MWQ2ZWUxOGJiNTRkOGUw
-    MDdhODRmYjg3OGU0OTdmMWViYTg5ODEyOWExYTI3ZWUyMjY1YTBiMjk3N2Q0
-    MmViOWQzOTc5MTlkOTJhYzE2M2RmZTE1OGFmMGMzY2YwMWM1NWU=
-  data.tar.gz: !binary |-
-    YmViOTViODYyOWMxNDg0YTVhZDAyNmRjMTkzZGI0NDY0ZDk5OGU1NDE4NTQ4
-    ZmExMWUyYTVkZDVjYmRiZGQ5OGM5MzFmOTkyODY5YzExYzA4NTMzMTcwZjNl
-    YTU3YjdhMjMxN2ExZThkNTY4NzhkMDc3MTRhYmUzNjE1NmY4OGY=
+--- 
+SHA1: 
+  metadata.gz: bb1cdf1d80f8dca2f87ad8233000a3e659f9ad05
+  data.tar.gz: cfb06027c385cc3bbe4ab089a721eb6dbe1ac531
+SHA512: 
+  metadata.gz: 54efaacd4b1700ac6d88e18c03e75b1cc831abd1b43f1e65618644fd03a838a9e615f8344fb0b22147e01d5e3a717fbfe857085db1e96fc2a5cf423ce180cf36
+  data.tar.gz: 84854349a891d82f5acd8d1cc0582d758fd4857c60580ff2109246feab7fdc70fafa03875a6b18bb8095659887b74432ea97fca769489a024d875e336c86b7d5

data/.gitmodules

@@ -1,3 +1,3 @@
 [submodule "coffeelint"]
 	path = coffeelint
-	url = git://github.com/zipcodeman/coffeelint.git
+	url = git://github.com/clutchski/coffeelint.git

data/README.md

@@ -1,4 +1,4 @@
-# Coffeelint
+# Coffeelint [![Gem Version](https://badge.fury.io/rb/coffeelint.png)](http://badge.fury.io/rb/coffeelint)
 
 Coffeelint is a set of simple ruby bindings for [coffeelint](https://github.com/clutchski/coffeelint).
 
@@ -25,18 +25,29 @@ Or install it yourself as:
 There are a few different uses of coffeelint.
 
 ```ruby
-lint_report = Coffeelint.lint(coffeescript source code)
-lint_report = Coffeelint.lint_file(filename of coffeescript source)
-lint_reports = Coffeelint.lint_dir(directory)
-Coffeelint.lint_dir(directory) do |filename, lint_report|
+lint_report = Coffeelint.lint(coffeescript source code, [config options])
+lint_report = Coffeelint.lint_file(filename of coffeescript source, [config_options])
+lint_reports = Coffeelint.lint_dir(directory, [config_options])
+Coffeelint.lint_dir(directory, [config_options]) do |filename, lint_report|
     puts filename
     puts lint_report
     Coffeelint.display_test_results(filename, lint_report)
 end
-Coffeelint.run_test(filename of coffeescript source) # Run tests and print pretty results (return true/false)
-Coffeelint.run_test_suite(directory) # Runs a pretty report recursively for a directory (return true/false)
+Coffeelint.run_test(filename of coffeescript source, [config_options]) # Run tests and print pretty results (return true/false)
+Coffeelint.run_test_suite(directory, [config_options]) # Runs a pretty report recursively for a directory (return true/false)
 ```
 
+### Config Options
+
+The coffeelint gem takes the same config options as coffeelint. The only
+addition is the config_file parameter. If you call coffeelint like:
+
+```ruby
+Coffeelint.run_test_suite(directory, :config_file => 'coffeelint_config.json')
+```
+
+Then it will load the config options from that file.
+
 Additionally, if you are using rails you also get the rake task:
 
     rake coffeelint
@@ -47,6 +58,7 @@ Finally, there is a command line utility that allows you to run standalone tests
 
     coffeelint.rb <filename>
     coffeelint.rb -r <directory>
+    coffeelint.rb -f <config.json> [-r] <fname-or-directory>
 
 ## Contributing
 

data/bin/coffeelint.rb

@@ -1,21 +1,79 @@
 #!/usr/bin/env ruby
 
 require 'coffeelint'
+require 'coffeelint/version'
 require 'optparse'
 
-options = {:recursive => false}
-OptionParser.new do |opts|
-  opts.banner = "Usage: coffeelint [options] source [...]"
+options = {
+            :recursive => false,
+            :noconfig => false,
+            :stdin => false,
+            :quiet => false,
+          }
 
-  opts.on '-r', "Recursively lint .coffee files in subdirectories." do |f|
-    options[:recursive] = f
+linter_options = {}
+
+opt_parser = OptionParser.new do |opts|
+  opts.banner = "Usage: coffeelint.rb [options] source [...]"
+
+=begin
+-f, --file     Specify a custom configuration file.               
+--noconfig     Ignores the environment variable COFFEELINT_CONFIG.  [boolean]
+-h, --help     Print help information.                            
+-v, --version  Print current version number.                      
+-r             Recursively lint .coffee files in subdirectories.    [boolean]
+--csv          Use the csv reporter.                                [boolean]
+--jslint       Use the JSLint XML reporter.                         [boolean]
+--nocolor      Don't colorize the output                            [boolean]
+-s, --stdin    Lint the source from stdin                           [boolean]
+-q, --quiet    Only print errors.                                   [boolean]
+=end
+
+
+  opts.on "-f", "--file", "Specify a custom configuration file." do |f|
+    linter_options[:config_file] = f
+  end
+
+=begin
+  opts.on "--noconfig", "Ignores the environment variabel COFFEELINT_CONFIG." do |f|
+    options[:noconfig] = true
+  end
+=end
+
+  opts.on_tail "-h", "--help", "Print help information." do
+    puts opts
+    exit
+  end
+
+  opts.on_tail "-v", "--version", "Print current version number." do
+    puts Coffeelint::VERSION
+    exit
   end
-end.parse!
 
-ARGV.each do |file|
-  if options[:recursive]
-    Coffeelint.run_test_suite(file)
-  else
-    Coffeelint.run_test(file)
+  opts.on '-r', "Recursively lint .coffee files in subdirectories." do
+    options[:recursive] = true
+  end
+
+=begin
+  opts.on '-s', '--stdin', "Lint the source from stdin" do
+    options[:stdin] = true
+  end
+
+  opts.on '-q', '--quiet', 'Only print errors.' do
+    options[:quiet] = true
+  end
+=end
+
+end
+
+opt_parser.parse!
+
+if ARGV.length > 0
+  ARGV.each do |file|
+    if options[:recursive]
+      Coffeelint.run_test_suite(file, linter_options)
+    else
+      Coffeelint.run_test(file, linter_options)
+    end
   end
 end

data/coffeelint/src/coffeelint.coffee

@@ -23,7 +23,7 @@ else
 
 
 # The current version of Coffeelint.
-coffeelint.VERSION = "0.5.4"
+coffeelint.VERSION = "0.5.7"
 
 
 # CoffeeLint error levels.
@@ -38,41 +38,144 @@ coffeelint.RULES = RULES =
     no_tabs :
         level : ERROR
         message : 'Line contains tab indentation'
+        description: """
+            This rule forbids tabs in indentation. Enough said. It is enabled by
+            default.
+            """
 
     no_trailing_whitespace :
         level : ERROR
         message : 'Line ends with trailing whitespace'
         allowed_in_comments : false
+        description: """
+            This rule forbids trailing whitespace in your code, since it is
+            needless cruft. It is enabled by default.
+            """
 
     max_line_length :
         value: 80
         level : ERROR
         message : 'Line exceeds maximum allowed length'
+        description: """
+            This rule imposes a maximum line length on your code. <a
+            href="http://www.python.org/dev/peps/pep-0008/">Python's style
+            guide</a> does a good job explaining why you might want to limit the
+            length of your lines, though this is a matter of taste.
+
+            Lines can be no longer than eighty characters by default.
+            """
 
     camel_case_classes :
         level : ERROR
         message : 'Class names should be camel cased'
-
+        description: """
+            This rule mandates that all class names are camel cased. 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.
+            <pre>
+            <code># Good!
+            class BoaConstrictor
+
+            # Bad!
+            class boaConstrictor
+            </code>
+            </pre>
+            This rule is enabled by default.
+            """
     indentation :
         value : 2
         level : ERROR
         message : 'Line contains inconsistent indentation'
+        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. <pre> <code>#
+            Enabling this option will prevent this ugly
+            # but otherwise valid CoffeeScript.
+            twoSpaces = () ->
+              fourSpaces = () ->
+                  eightSpaces = () ->
+                        'this is valid CoffeeScript'
+
+            </code>
+            </pre>
+            Two space indentation is enabled by default.
+            """
 
     no_implicit_braces :
         level : IGNORE
         message : 'Implicit braces are forbidden'
+        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.
+            <pre>
+            <code># Do you find this code ambiguous? Is it a
+            # function call with three arguments or four?
+            myFunction a, b, 1:2, 3:4
+
+            # While the same code written in a more
+            # explicit manner has no ambiguity.
+            myFunction(a, b, {1:2, 3:4})
+            </code>
+            </pre>
+            Implicit braces are permitted by default, since their use is
+            idiomatic CoffeeScript.
+            """
 
     no_trailing_semicolons:
         level : ERROR
         message : 'Line contains a trailing semicolon'
+        description: """
+            This rule prohibits trailing semicolons, since they are needless
+            cruft in CoffeeScript.
+            <pre>
+            <code># This semicolon is meaningful.
+            x = '1234'; console.log(x)
+
+            # This semicolon is redundant.
+            alert('end of line');
+            </code>
+            </pre>
+            Trailing semicolons are forbidden by default.
+            """
 
     no_plusplus:
         level : IGNORE
         message : 'The increment and decrement operators are forbidden'
+        description: """
+            This rule forbids the increment and decrement arithmetic operators.
+            Some people believe the <tt>++</tt> and <tt>--</tt> to be cryptic
+            and the cause of bugs due to misunderstandings of their precedence
+            rules.
+            This rule is disabled by default.
+            """
 
     no_throwing_strings:
         level : ERROR
         message : 'Throwing strings is forbidden'
+        description: """
+            This rule forbids throwing string literals or interpolations. While
+            JavaScript (and CoffeeScript by extension) allow any expression to
+            be thrown, it is best to only throw <a
+            href="https://developer.mozilla.org
+            /en/JavaScript/Reference/Global_Objects/Error"> Error</a> objects,
+            because they contain valuable debugging information like the stack
+            trace. Because of JavaScript's dynamic nature, CoffeeLint cannot
+            ensure you are always throwing instances of <tt>Error</tt>. It will
+            only catch the simple but real case of throwing literal strings.
+            <pre>
+            <code># CoffeeLint will catch this:
+            throw "i made a boo boo"
+
+            # ... but not this:
+            throw getSomeString()
+            </code>
+            </pre>
+            This rule is enabled by default.
+            """
 
     cyclomatic_complexity:
         value : 10
@@ -82,15 +185,39 @@ coffeelint.RULES = RULES =
     no_backticks:
         level : ERROR
         message : 'Backticks are forbidden'
+        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 <tt>with</tt> and <tt>eval</tt>,
+            sneak into CoffeeScript.
+            This rule is enabled by default.
+            """
 
     line_endings:
         level : IGNORE
         value : 'unix' # or 'windows'
         message : 'Line contains incorrect line endings'
-
+        description: """
+            This rule ensures your project uses only <tt>windows</tt> or
+            <tt>unix</tt> line endings. This rule is disabled by default.
+            """
     no_implicit_parens :
         level : IGNORE
         message : 'Implicit parens are forbidden'
+        description: """
+            This rule prohibits implicit parens on function calls.
+            <pre>
+            <code># Some folks don't like this style of coding.
+            myFunction a, b, c
+
+            # And would rather it always be written like this:
+            myFunction(a, b, c)
+            </code>
+            </pre>
+            Implicit parens are permitted by default, since their use is
+            idiomatic CoffeeScript.
+            """
 
     empty_constructor_needs_parens :
         level : IGNORE
@@ -103,6 +230,19 @@ coffeelint.RULES = RULES =
     no_empty_param_list :
         level : IGNORE
         message : 'Empty parameter list is forbidden'
+        description: """
+            This rule prohibits empty parameter lists in function definitions.
+            <pre>
+            <code># The empty parameter list in here is unnecessary:
+            myFunction = () -&gt;
+
+            # We might favor this instead:
+            myFunction = -&gt;
+            </code>
+            </pre>
+            Empty parameter lists are permitted by default.
+            """
+
 
     space_operators :
         level : IGNORE
@@ -124,10 +264,33 @@ coffeelint.RULES = RULES =
     no_stand_alone_at :
         level : IGNORE
         message : '@ must not be used stand alone'
+        description: """
+            This rule checks that no stand alone @ are in use, they are
+            discouraged. Further information in CoffeScript issue <a
+            href="https://github.com/jashkenas/coffee-script/issues/1601">
+            #1601</a>
+            """
 
     arrow_spacing :
         level : IGNORE
         message : 'Function arrow (->) must be spaced properly'
+        description: """
+            <p>This rule checks to see that there is spacing before and after
+            the arrow operator that declares a function. This rule is disabled
+            by default.</p> <p>Note that if arrow_spacing is enabled, and you
+            pass an empty function as a parameter, arrow_spacing will accept
+            either a space or no space in-between the arrow operator and the
+            parenthesis</p>
+            <pre><code># Both of this will not trigger an error,
+            # even with arrow_spacing enabled.
+            x(-> 3)
+            x( -> 3)
+
+            # However, this will trigger an error
+            x((a,b)-> 3)
+            </code>
+            </pre>
+             """
 
     coffeescript_error :
         level : ERROR
@@ -265,8 +428,10 @@ class LineLinter
     checkLineLength : () ->
         rule = 'max_line_length'
         max = @config[rule]?.value
-        if max and max < @line.length
-            @createLineError(rule) unless regexes.longUrlComment.test(@line)
+        if max and max < @line.length and not regexes.longUrlComment.test(@line)
+            attrs =
+                context: "Length is #{@line.length}, max is #{max}"
+            @createLineError(rule, attrs)
         else
             null
 
@@ -378,8 +543,7 @@ class LineLinter
         null
 
 #
-# A class that performs checks on the output of CoffeeScript's
-# lexer.
+# A class that performs checks on the output of CoffeeScript's lexer.
 #
 class LexicalLinter
 
@@ -405,8 +569,7 @@ class LexicalLinter
             errors.push(error) if error
         errors
 
-    # Return an error if the given token fails a lint check, false
-    # otherwise.
+    # Return an error if the given token fails a lint check, false otherwise.
     lintToken : (token) ->
         [type, value, lineNumber] = token
 
@@ -437,17 +600,26 @@ class LexicalLinter
             when "PARAM_START"            then @lintParam(token)
             when "@"                      then @lintStandaloneAt(token)
             when "+", "-"                 then @lintPlus(token)
-            when "=", "MATH", "COMPARE", "LOGIC"
+            when "=", "MATH", "COMPARE", "LOGIC", "COMPOUND_ASSIGN"
                 @lintMath(token)
             else null
 
     lintUnary: (token) ->
         if token[1] is 'new'
-            expectedIdentifier = @peek(1)
+            # Find the last chained identifier, e.g. Bar in new foo.bar.Bar().
+            identifierIndex = 1
+            loop
+                expectedIdentifier = @peek(identifierIndex)
+                expectedCallStart  = @peek(identifierIndex + 1)
+                if expectedIdentifier?[0] is 'IDENTIFIER'
+                    if expectedCallStart?[0] is '.'
+                        identifierIndex += 2
+                        continue
+                break
+
             # The callStart is generated if your parameters are all on the same
             # line with implicit parens, and if your parameters start on the
             # next line, but is missing if there are no params and no parens.
-            expectedCallStart  = @peek(2)
             if expectedIdentifier?[0] is 'IDENTIFIER' and expectedCallStart?
                 if expectedCallStart[0] is 'CALL_START'
                     if expectedCallStart.generated
@@ -500,7 +672,8 @@ class LexicalLinter
         p = @peek(-1)
         unaries = ['TERMINATOR', '(', '=', '-', '+', ',', 'CALL_START',
                     'INDEX_START', '..', '...', 'COMPARE', 'IF',
-                    'THROW', 'LOGIC', 'POST_IF', ':', '[', 'INDENT']
+                    'THROW', 'LOGIC', 'POST_IF', ':', '[', 'INDENT',
+                    'COMPOUND_ASSIGN', 'RETURN', 'MATH']
         isUnary = if not p then false else p[0] in unaries
         if (isUnary and token.spaced) or
                     (not isUnary and not token.spaced and not token.newLine)
@@ -602,7 +775,16 @@ class LexicalLinter
         isIndexStart = nextToken[0] == 'INDEX_START'
         isDot = nextToken[0] == '.'
 
-        if spaced or (not isIdentifier and not isIndexStart and not isDot)
+        # https://github.com/jashkenas/coffee-script/issues/1601
+        # @::foo is valid, but @:: behaves inconsistently and is planned for
+        # removal. Technically @:: is a stand alone ::, but I think it makes
+        # sense to group it into no_stand_alone_at
+        if nextToken[0] == '::'
+            protoProperty = @peek(2)
+            isValidProtoProperty = protoProperty[0] == 'IDENTIFIER'
+
+        if spaced or (not isIdentifier and not isIndexStart and
+        not isDot and not isValidProtoProperty)
             @createLexError('no_stand_alone_at')
 
 
@@ -640,9 +822,13 @@ class LexicalLinter
         # lines, which can be ignored.
         if @isChainedCall()
             currentLine = @lines[@lineNumber]
-            previousLine = @lines[@lineNumber - 1]
-            previousIndentation = previousLine.match(/^(\s*)/)[1].length
+            prevNum = 1
 
+            # keep going back until we are not at a comment or a blank line
+            prevNum += 1 while (/^\s*(#|$)/.test(@lines[@lineNumber - prevNum]))
+            previousLine = @lines[@lineNumber - prevNum]
+
+            previousIndentation = previousLine.match(/^(\s*)/)[1].length
             # I don't know why, but when inside a function, you make a chained
             # call and define an inline callback as a parameter, the body of
             # that callback gets the indentation reported higher than it really
@@ -691,7 +877,7 @@ class LexicalLinter
 
     lintArrowSpacing : (token) ->
         # Throw error unless the following happens.
-
+        #
         # We will take a look at the previous token to see
         # 1. That the token is properly spaced
         # 2. Wasn't generated by the CoffeeScript compiler
@@ -699,13 +885,19 @@ class LexicalLinter
         # 4. If the function declaration has no parameters
         # e.g. x(-> 3)
         #      x( -> 3)
+        #
+        # or a statement is wrapped in parentheses
+        # e.g. (-> true)()
+        #
         # we will accept either having a space or not having a space there.
+
+        pp = @peek(-1)
         unless (token.spaced? or token.newLine?) and
                # Throw error unless the previous token...
-               (@peek(-1).spaced? or #1
-                @peek(-1).generated? or #2
-                @peek(-1)[0] is "INDENT" or #3
-                (@peek(-1)[0] is "CALL_START" and not @peek(-1).generated?)) #4
+               ((pp.spaced? or pp[0] is 'TERMINATOR') or #1
+                pp.generated? or #2
+                pp[0] is "INDENT" or #3
+                (pp[1] is "(" and not pp.generated?)) #4
             @createLexError('arrow_spacing')
         else
             null
@@ -763,10 +955,8 @@ class ASTLinter
         @lintNode(@node)
         @errors
 
-    # Lint the AST node and return it's cyclomatic complexity.
-    lintNode : (node) ->
-
-        # Get the complexity of the current node.
+    # returns the "complexity" value of the current node.
+    getComplexity : (node) ->
         name = node.constructor.name
         complexity = if name in ['If', 'While', 'For', 'Try']
             1
@@ -776,21 +966,30 @@ class ASTLinter
             node.cases.length
         else
             0
+        return complexity
+
+    # Lint the AST node and return it's cyclomatic complexity.
+    lintNode : (node, line) ->
+
+        # Get the complexity of the current node.
+        name = node.constructor.name
+        complexity = @getComplexity(node)
 
         # Add the complexity of all child's nodes to this one.
         node.eachChild (childNode) =>
-            return false unless childNode
-            complexity += @lintNode(childNode)
-            return true
+            nodeLine = childNode.locationData.first_line
+            complexity += @lintNode(childNode, nodeLine) if childNode
 
         # If the current node is a function, and it's over our limit, add an
         # error to the list.
         rule = @config.cyclomatic_complexity
+
         if name == 'Code' and complexity >= rule.value
             attrs = {
                 context: complexity + 1
                 level: rule.level
-                line: 0
+                lineNumber: line + 1
+                lineNumberEnd: node.locationData.last_line + 1
             }
             error = createError 'cyclomatic_complexity', attrs
             @errors.push error if error
@@ -826,6 +1025,22 @@ mergeDefaultConfig = (userConfig) ->
         config[rule] = defaults(userConfig[rule], ruleConfig)
     return config
 
+coffeelint.invertLiterate = (source) ->
+    source = CoffeeScript.helpers.invertLiterate source
+    # Strip the first 4 spaces from every line. After this the markdown is
+    # commented and all of the other code should be at their natural location.
+    newSource = ""
+    for line in source.split "\n"
+        if line.match(/^#/)
+            # strip trailing space
+            line = line.replace /\s*$/, ''
+        # Strip the first 4 spaces of every line. This is how Markdown
+        # indicates code, so in the end this pulls everything back to where it
+        # would be indented if it hadn't been written in literate style.
+        line = line.replace /^\s{4}/g, ''
+        newSource += "#{line}\n"
+
+    newSource
 
 # Check the source against the given configuration and return an array
 # of any errors found. An error is an object with the following
@@ -839,14 +1054,16 @@ mergeDefaultConfig = (userConfig) ->
 #       context:    'Optional details about why the rule was violated'
 #   }
 #
-coffeelint.lint = (source, userConfig = {}) ->
+coffeelint.lint = (source, userConfig = {}, literate = false) ->
+    source = @invertLiterate source if literate
+
     config = mergeDefaultConfig(userConfig)
 
     # Check ahead for inline enabled rules
     disabled_initially = []
     for l in source.split('\n')
         s = regexes.configStatement.exec(l)
-        if s? and s.length > 2 and 'enable' in s
+        if s?.length > 2 and 'enable' in s
             for r in s[1..]
                 unless r in ['enable','disable']
                     unless r of config and config[r].level in ['warn','error']

data/lib/coffeelint.rb

@@ -9,51 +9,71 @@ module Coffeelint
     @path ||= File.expand_path('../../coffeelint/src/coffeelint.coffee', __FILE__)
   end
 
-  def self.lint(script)
+  def self.colorize(str, color_code)
+    "\e[#{color_code}m#{str}\e[0m"
+  end
+
+  def self.red(str, pretty_output = true)
+    pretty_output ? Coffeelint.colorize(str, 31) : str
+  end
+
+  def self.green(str, pretty_output = true)
+    pretty_output ? Coffeelint.colorize(str, 32) : str
+  end
+
+  def self.lint(script, config = {})
+    if !config[:config_file].nil?
+      fname = config.delete(:config_file)
+      config.merge!(JSON.parse(File.read(fname)))
+    end
     coffeescriptSource = File.read(CoffeeScript::Source.path)
     coffeelintSource = CoffeeScript.compile(File.read(Coffeelint.path))
     context = ExecJS.compile(coffeescriptSource + coffeelintSource)
-    context.call('coffeelint.lint', script)
+    context.call('coffeelint.lint', script, config)
   end
 
-  def self.lint_file(filename)
-    Coffeelint.lint(File.read(filename))
+  def self.lint_file(filename, config = {})
+    Coffeelint.lint(File.read(filename), config)
   end
 
-  def self.lint_dir(directory)
+  def self.lint_dir(directory, config = {})
     retval = {}
     Dir.glob("#{directory}/**/*.coffee") do |name|
-      retval[name] = Coffeelint.lint_file(name)
+      retval[name] = Coffeelint.lint_file(name, config)
       yield name, retval[name] if block_given?
     end
     retval
   end
 
-  def self.display_test_results(name, errors)
-    good = "\u2713"
-    bad = "\u2717"
+  def self.display_test_results(name, errors, pretty_output = true)
+    good = pretty_output ? "\u2713" : 'Passed'
+    bad = pretty_output ? "\u2717" : 'Failed'
 
     if errors.length == 0
-      puts "  #{good} \e[1m\e[32m#{name}\e[0m"
+      puts "  #{good} " + Coffeelint.green(name, pretty_output)
       return true
     else
-      puts "  #{bad} \e[1m\e[31m#{name}\e[0m"
+      puts "  #{bad} " + Coffeelint.red(name, pretty_output)
       errors.each do |error|
-        puts "     #{bad} \e[31m##{error["lineNumber"]}\e[0m: #{error["message"]}, #{error["context"]}."
+        print "     #{bad} "
+        print Coffeelint.red(error["lineNumber"], pretty_output)
+        puts ": #{error["message"]}, #{error["context"]}."
       end
       return false
     end
   end
 
-  def self.run_test(file)
-    result = Coffeelint.lint_file(file)
-    Coffeelint.display_test_results(file, result)
+  def self.run_test(file, config = {})
+    pretty_output = config.has_key?(:pretty_output) ? config.delete(:pretty_output) : true
+    result = Coffeelint.lint_file(file, config)
+    Coffeelint.display_test_results(file, result, pretty_output)
   end
 
-  def self.run_test_suite(directory)
+  def self.run_test_suite(directory, config = {})
+    pretty_output = config.has_key?(:pretty_output) ? config.delete(:pretty_output) : true
     success = true
-    Coffeelint.lint_dir(directory) do |name, errors|
-      result = Coffeelint.display_test_results(name, errors)
+    Coffeelint.lint_dir(directory, config) do |name, errors|
+      result = Coffeelint.display_test_results(name, errors, pretty_output)
       success = false if not result
     end
     success

data/lib/coffeelint/version.rb

@@ -1,3 +1,3 @@
 module Coffeelint
-  VERSION = "0.0.6"
+  VERSION = "0.1.2"
 end

data/spec/coffeelint_spec.rb

@@ -7,4 +7,15 @@ describe Coffeelint do
     result = results[0]
     result['message'].should include 'trailing semicolon'
   end
+
+  it 'should be able to disable a linter' do
+    results = Coffeelint.lint('apple;', :no_trailing_semicolons =>  { :level => "ignore" } )
+    results.length.should == 0
+  end
+
+  it 'should be able to take a config file in the parameters' do
+    File.open('/tmp/coffeelint.json', 'w') {|f| f.write(JSON.dump({:no_trailing_semicolons => { :level => "ignore" }})) }
+    results = Coffeelint.lint('apple;', :config_file => "/tmp/coffeelint.json")
+    results.length.should == 0
+  end
 end

metadata

@@ -1,65 +1,53 @@
---- !ruby/object:Gem::Specification
+--- !ruby/object:Gem::Specification 
 name: coffeelint
-version: !ruby/object:Gem::Version
-  version: 0.0.6
+version: !ruby/object:Gem::Version 
+  version: 0.1.2
 platform: ruby
-authors:
+authors: 
 - Zachary Bush
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-05-10 00:00:00.000000000 Z
-dependencies:
-- !ruby/object:Gem::Dependency
+
+date: 2013-10-20 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
   name: coffee-script
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
   prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - &id002 
+      - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
   name: rspec
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
   prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: rake
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    requirements: 
+    - *id002
   type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: rake
   prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    requirements: 
+    - *id002
+  type: :development
+  version_requirements: *id004
 description: Ruby bindings for coffeelint
-email:
+email: 
 - zach@zmbush.com
-executables:
+executables: 
 - coffeelint.rb
 extensions: []
+
 extra_rdoc_files: []
-files:
+
+files: 
 - .gitignore
 - .gitmodules
 - Gemfile
@@ -76,29 +64,28 @@ files:
 - spec/spec_helper.rb
 - coffeelint/src/coffeelint.coffee
 homepage: https://github.com/zipcodeman/coffeelint-ruby
-licenses:
+licenses: 
 - MIT
 metadata: {}
+
 post_install_message: 
 rdoc_options: []
-require_paths:
+
+require_paths: 
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement
-  requirements:
-  - - ! '>='
-    - !ruby/object:Gem::Version
-      version: '0'
-required_rubygems_version: !ruby/object:Gem::Requirement
-  requirements:
-  - - ! '>='
-    - !ruby/object:Gem::Version
-      version: '0'
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - *id002
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - *id002
 requirements: []
+
 rubyforge_project: 
-rubygems_version: 2.0.3
+rubygems_version: 2.1.9
 signing_key: 
 specification_version: 4
 summary: Ruby bindings for coffeelint along with railtie to add rake task to rails
-test_files:
+test_files: 
 - spec/coffeelint_spec.rb
 - spec/spec_helper.rb