Merge pull request #491 from sasstools/release/1.5.0

Release/1.5.0

Author: DanPurdy

CHANGELOG.md

@@ -1,5 +1,24 @@
 # Sass Lint Changelog
 
+## v1.5.0
+**January 28, 2016**
+
+New year blues
+
+**Changes**
+* AST parse errors will now be returned to the user as `Fatal` lint errors this prevents un-handled errors breaking builds [#459](https://github.com/sasstools/sass-lint/pull/459)
+* Sass-lint plugin for Brackets added to the README [#470](https://github.com/sasstools/sass-lint/issues/470)
+* Sass-lint plugin for IntelliJ IDEA, RubyMine, WebStorm, PhpStorm, PyCharm, added to the README [#484](https://github.com/sasstools/sass-lint/issues/484)
+
+
+**CLI**
+* Updated error codes, whenever errors are present even when cli is using the `--no-exit` flag a error code of 1 will be output [#221](https://github.com/sasstools/sass-lint/issues/221)
+
+**Fixes**
+* Fixed an issue where an error of `next is undefined` would be thrown in the `space-after-colon` rule [#468](https://github.com/sasstools/sass-lint/issues/468)
+* Fixed an issue with negative z-index values in the `space-around-operator` rule [#454](https://github.com/sasstools/sass-lint/issues/454)
+* Fixed another minor issue with `space-around-operator` to prevent a possible crash [#483](https://github.com/sasstools/sass-lint/issues/483)
+
 ## v1.4.0
 **December 10, 2015**
 
@@ -39,6 +58,7 @@ The long overdue update!
 * [Dan Purdy](https://github.com/DanPurdy)
 * [Ben Rothman](https://github.com/benthemonkey)
 * [Don Abrams](https://github.com/donabrams)
+* [Andrew Hays](https://github.com/Dru89)
 * [Kaelig](https://github.com/kaelig)
 
 **A big thankyou to everyone who reported issues or contributed to the discussion around issues**

README.md

@@ -54,3 +54,5 @@ Our AST is [Gonzales-PE](https://github.com/tonyganch/gonzales-pe/tree/dev). Eac
 
 * [Atom](https://atom.io/packages/linter-sass-lint)
 * [Sublime Text](https://github.com/skovhus/SublimeLinter-contrib-sass-lint)
+* [Brackets](https://github.com/petetnt/brackets-sass-lint)
+* [IntelliJ IDEA, RubyMine, WebStorm, PhpStorm, PyCharm](https://github.com/idok/sass-lint-plugin)

bin/sass-lint.js

@@ -7,7 +7,8 @@ var program = require('commander'),
 
 var configPath,
     ignores,
-    configOptions = {};
+    configOptions = {},
+    exitCode = 0;
 
 var detectPattern = function (pattern) {
   var detects;
@@ -18,6 +19,10 @@ var detectPattern = function (pattern) {
     lint.outputResults(detects, configOptions, configPath);
   }
 
+  if (lint.errorCount(detects).count) {
+    exitCode = 1;
+  }
+
   if (program.exit) {
     lint.failOnError(detects);
   }
@@ -86,3 +91,7 @@ else {
     detectPattern(path);
   });
 }
+
+process.on('exit', function () {
+  process.exit(exitCode); // eslint-disable-line no-process-exit
+});

index.js

@@ -6,40 +6,119 @@ var slConfig = require('./lib/config'),
     slRules = require('./lib/rules'),
     glob = require('glob'),
     path = require('path'),
-    jsonFormatter = require('eslint/lib/formatters/json'),
     fs = require('fs-extra');
 
-
 var sassLint = function (config) {
   config = require('./lib/config')(config);
   return;
 };
 
+/**
+ * Takes any user specified options and a configPath
+ * which returns a compiled config object
+ *
+ * @param {object} config user specified rules/options passed in
+ * @param {string} configPath path to a config file
+ * @returns {object} the compiled config object
+ */
 sassLint.getConfig = function (config, configPath) {
   return slConfig(config, configPath);
 };
 
-sassLint.resultCount = function (results) {
-  var flagCount = 0,
-      jsonResults = JSON.parse(jsonFormatter(results));
+/**
+ * Parses our results object to count errors and return
+ * paths to files with detected errors.
+ *
+ * @param {object} results our results object
+ * @returns {object} errors object containing the error count and paths for files incl. errors
+ */
+sassLint.errorCount = function (results) {
+  var errors = {
+    count: 0,
+    files: []
+  };
 
+  results.forEach(function (result) {
+    if (result.errorCount) {
+      errors.count += result.errorCount;
+      errors.files.push(result.filePath);
+    }
+  });
 
-  for (var i = 0; i < jsonResults.length; i++) {
-    flagCount += (jsonResults[i].warningCount + jsonResults[i].errorCount);
-  }
+  return errors;
+};
+
+/**
+ * Parses our results object to count warnings and return
+ * paths to files with detected warnings.
+ *
+ * @param {object} results our results object
+ * @returns {object} warnings object containing the error count and paths for files incl. warnings
+ */
+sassLint.warningCount = function (results) {
+  var warnings = {
+    count: 0,
+    files: []
+  };
+
+  results.forEach(function (result) {
+    if (result.warningCount) {
+      warnings.count += result.warningCount;
+      warnings.files.push(result.filePath);
+    }
+  });
 
-  return flagCount;
+  return warnings;
 };
 
+/**
+ * Parses our results object to count warnings and errors and return
+ * a cumulative count of both
+ *
+ * @param {object} results our results object
+ * @returns {int} the cumulative count of errors and warnings detected
+ */
+sassLint.resultCount = function (results) {
+  var warnings = this.warningCount(results),
+      errors = this.errorCount(results);
+
+  return warnings.count + errors.count;
+};
+
+/**
+ * Runs each rule against our AST tree and returns our main object of detected
+ * errors, warnings, messages and filenames.
+ *
+ * @param {object} file file object from fs.readFileSync
+ * @param {object} options user specified rules/options passed in
+ * @param {string} configPath path to a config file
+ * @returns {object} an object containing error & warning counts plus lint messages for each parsed file
+ */
 sassLint.lintText = function (file, options, configPath) {
   var rules = slRules(this.getConfig(options, configPath)),
-      ast = groot(file.text, file.format, file.filename),
+      ast = {},
       detects,
       results = [],
       errors = 0,
       warnings = 0;
 
-  if (ast.content.length > 0) {
+  try {
+    ast = groot(file.text, file.format, file.filename);
+  }
+  catch (e) {
+    var line = e.line || 1;
+    errors++;
+
+    results = [{
+      ruleId: 'Fatal',
+      line: line,
+      column: 1,
+      message: e.message,
+      severity: 2
+    }];
+  }
+
+  if (ast.content && ast.content.length > 0) {
     rules.forEach(function (rule) {
       detects = rule.rule.detect(ast, rule);
       results = results.concat(detects);
@@ -54,7 +133,6 @@ sassLint.lintText = function (file, options, configPath) {
     });
   }
 
-
   results.sort(helpers.sortDetects);
 
   return {
@@ -65,6 +143,16 @@ sassLint.lintText = function (file, options, configPath) {
   };
 };
 
+/**
+ * Takes a glob pattern or target string and creates an array of files as targets for
+ * linting taking into account any user specified ignores. For each resulting file sassLint.lintText
+ * is called which returns an object of results for that file which we push to our results object.
+ *
+ * @param {string} files a glob pattern or single file path as a lint target
+ * @param {object} options user specified rules/options passed in
+ * @param {string} configPath path to a config file
+ * @returns {object} results object containing all results
+ */
 sassLint.lintFiles = function (files, options, configPath) {
   var that = this,
       results = [],
@@ -99,7 +187,14 @@ sassLint.lintFiles = function (files, options, configPath) {
   return results;
 };
 
-
+/**
+ * Handles formatting of results using EsLint formatters
+ *
+ * @param {object} results our results object
+ * @param {object} options user specified rules/options passed in
+ * @param {string} configPath path to a config file
+ * @returns {object} results our results object in the user specified format
+ */
 sassLint.format = function (results, options, configPath) {
   var config = this.getConfig(options, configPath),
       format = config.options.formatter.toLowerCase();
@@ -109,6 +204,15 @@ sassLint.format = function (results, options, configPath) {
   return formatted(results);
 };
 
+/**
+ * Handles outputting results whether this be straight to the console/stdout or to a file.
+ * Passes results to the format function to ensure results are output in the chosen format
+ *
+ * @param {object} results our results object
+ * @param {object} options user specified rules/options passed in
+ * @param {string} configPath path to a config file
+ * @returns {object} results our results object
+ */
 sassLint.outputResults = function (results, options, configPath) {
   var config = this.getConfig(options, configPath);
 
@@ -132,16 +236,18 @@ sassLint.outputResults = function (results, options, configPath) {
   return results;
 };
 
+/**
+ * Throws an error if there are any errors detected. The error includes a count of all errors
+ * and a list of all files that include errors.
+ *
+ * @param {object} results our results object
+ * @returns {void}
+ */
 sassLint.failOnError = function (results) {
-  var result,
-      i;
+  var errorCount = this.errorCount(results);
 
-  for (i = 0; i < results.length; i++) {
-    result = results[i];
-
-    if (result.errorCount > 0) {
-      throw new Error(result.errorCount + ' errors detected in ' + result.filePath);
-    }
+  if (errorCount.count > 0) {
+    throw new Error(errorCount.count + ' errors were detected in \n- ' + errorCount.files.join('\n- '));
   }
 };
 

lib/groot.js

@@ -6,8 +6,7 @@
 var gonzales = require('gonzales-pe');
 
 module.exports = function (text, syntax, filename) {
-  var fileInfo = filename ? ' at ' + filename : '',
-      tree;
+  var tree;
 
   // Run `.toString()` to allow Buffers to be passed in
   text = text.toString();
@@ -18,11 +17,20 @@ module.exports = function (text, syntax, filename) {
     });
   }
   catch (e) {
-    throw new Error('Parsing error' + fileInfo + ': ' + e.message);
+    throw {
+      message: e.message,
+      file: filename,
+      line: e.line
+    };
   }
 
   if (typeof tree === 'undefined') {
-    throw new Error('Undefined tree' + fileInfo + ': ' + text.toString() + ' => ' + tree.toString());
+    throw {
+      message: 'Undefined tree',
+      file: filename,
+      text: text.toString(),
+      tree: tree.toString()
+    };
   }
 
   return tree;

lib/rules.js

@@ -27,21 +27,30 @@ module.exports = function (config) {
   Object.keys(config.rules).forEach(function (rule) {
     var fullRule = config.rules[rule],
         loadRule,
+        severity,
         options,
         ruleSearch;
+
+    if (typeof fullRule === 'number') {
+      severity = fullRule;
+      options = {};
+    }
+    else {
+      severity = fullRule[0];
+      options = fullRule[1];
+    }
+
     // Only seek out rules that are enabled
-    if ((typeof fullRule === 'number' && fullRule !== 0) || (typeof fullRule === 'object' && fullRule[0] !== 0)) {
+    if (severity !== 0) {
       ruleSearch = searchArray(rules, rule);
       if (ruleSearch >= 0) {
         loadRule = require(rules[ruleSearch]);
 
-        options = typeof fullRule === 'object' ? fullRule[1] : {};
-
         options = merge.recursive(true, loadRule.defaults, options);
 
         handlers.push({
           'rule': loadRule,
-          'severity': typeof fullRule === 'number' ? fullRule : fullRule[0],
+          'severity': severity,
           'options': options
         });
       }

lib/rules/extends-before-declarations.js

@@ -13,7 +13,8 @@ module.exports = {
       var lastDeclaration = null;
 
       block.forEach(function (item, j) {
-        if (item.type === 'include' || item.type === 'extend') {
+        if ((item.type === 'include' || item.type === 'extend') &&
+            item.first('atkeyword')) {
           if (item.first('atkeyword').first('ident').content === 'extend') {
             if (j > lastDeclaration && lastDeclaration !== null) {
               item.forEach('simpleSelector', function () {

lib/rules/space-after-colon.js

@@ -14,7 +14,7 @@ module.exports = {
       if (delimiter.content === ':') {
         var next = parent.content[i + 1];
 
-        if (next.is('space')) {
+        if (next && next.is('space')) {
           if (!parser.options.include) {
             result = helpers.addUnique(result, {
               'ruleId': parser.rule.name,