Configuration: Auto-generation

Fixes #797
Closes gh-908

Author: mrjoelkemp

OVERVIEW.md

@@ -49,6 +49,16 @@ cat myfile.js | jscs
 
 ## CLI
 
+### `--auto-configure` (Experimental)
+Presents a walkthrough that allows you to generate a JSCS configuration by
+choosing a preset and handling violated rules.
+
+```
+jscs --auto-configure path
+```
+
+`path` can be a file or directory to check the presets against
+
 ### `--config`
 Allows to define path to the config file.
 ```

bin/jscs

@@ -15,6 +15,7 @@ program
     .usage('[options] <file ...>')
     .description('A code style linter for programmatically enforcing your style guide.')
     .option('-c, --config [path]', 'configuration file path')
+    .option('--auto-configure [path]', 'auto-generate a JSCS configuration file')
     .option('-e, --esnext', 'attempts to parse esnext code (currently es6)')
     .option('--es3', 'validates code as es3')
     .option('-s, --esprima <path>', 'attempts to use a custom version of Esprima')

lib/cli.js

@@ -7,6 +7,7 @@
  */
 var Checker = require('./checker');
 var configFile = require('./cli-config');
+var ConfigGenerator = require('./config/generator');
 
 var Vow = require('vow');
 var supportsColor = require('supports-color');
@@ -50,7 +51,7 @@ module.exports = function(program) {
      * Trying to load config.
      * Custom config path can be specified using '-c' option.
      */
-    if (!config && !program.preset) {
+    if (!config && !program.preset && !program.autoConfigure) {
         if (program.config) {
             console.error('Configuration source', program.config, 'was not found.');
         } else {
@@ -62,7 +63,7 @@ module.exports = function(program) {
         return returnArgs;
     }
 
-    if (!args.length && process.stdin.isTTY) {
+    if (!args.length && process.stdin.isTTY && typeof program.autoConfigure !== 'string') {
         console.error('No input files specified. Try option --help for usage information.');
         defer.reject(1);
 
@@ -96,6 +97,20 @@ module.exports = function(program) {
 
         return returnArgs;
     }
+    if (program.autoConfigure) {
+        var generator = new ConfigGenerator();
+
+        generator
+        .generate(program.autoConfigure)
+        .then(function() {
+            defer.resolve(0);
+        }, function(error) {
+            console.error('Configuration generation failed due to ', error);
+            defer.reject(1);
+        });
+
+        return returnArgs;
+    }
 
     // Handle usage like 'cat myfile.js | jscs' or 'jscs -''
     var usedDash = args[args.length - 1] === '-';

lib/config/generator.js

@@ -0,0 +1,274 @@
+var path = require('path');
+var fs = require('fs');
+
+var Vow = require('vow');
+var Table = require('cli-table');
+var prompt = require('prompt');
+var colors = require('colors');
+var assign = require('lodash.assign');
+
+var Checker = require('../checker');
+var utils = require('../utils');
+
+prompt.message = '';
+prompt.delimiter = '';
+prompt.start();
+
+/**
+ * Script that walks the user through the autoconfig flow
+ *
+ * @type {String[]}
+ * @private
+ */
+var prompts = [
+    {
+        name: colors.green('Please choose a preset number:'),
+        require: true,
+        pattern: /\d+/
+    },
+    {
+        name: 'Create an (e)xception for this rule, or (f)ix the errors yourself?',
+        require: true,
+        pattern: /(e|f)/
+    }
+];
+
+/**
+ * JSCS Configuration Generator
+ *
+ * @name Generator
+ */
+function Generator() {
+    this._config = {};
+}
+
+/**
+ * Generates a configuration object based for the given path
+ * based on the best fitting preset
+ *
+ * @param  {String} path - The path containing file(s) used to guide the configuration
+ *
+ * @return {Promise} Resolved with the generated, JSCS configuration
+ */
+Generator.prototype.generate = function(path) {
+    var checker = getChecker();
+    var _path = utils.normalizePath(path, checker.getConfiguration().getBasePath());
+    var presetNames = Object.keys(checker.getConfiguration().getRegisteredPresets());
+    var statsForPresets;
+
+    console.log('Checking', _path, 'against the presets');
+
+    return Vow
+    .all(presetNames.map(this._checkAgainstPreset.bind(this, _path)))
+    .then(function(resultsPerPreset) {
+        statsForPresets = this._generateStatsForPresets(resultsPerPreset, presetNames);
+        return statsForPresets;
+    }.bind(this))
+    .then(this._showErrorCounts.bind(this))
+    .then(this._getUserPresetChoice.bind(this, prompts[0]))
+    .then(function showViolatedRules(choiceObj) {
+        var presetIndex = choiceObj[prompts[0].name] - 1;
+        var presetName = statsForPresets[presetIndex].name;
+
+        console.log('You chose the ' + presetName + ' preset');
+
+        this._config.preset = presetName;
+
+        var errorList = statsForPresets[presetIndex].errors;
+        errorList = getUniqueErrorNames(errorList);
+
+        var violatedRuleCount = errorList.length;
+
+        if (!violatedRuleCount) { return this._config; }
+
+        console.log(_path + ' violates ' + violatedRuleCount + ' rule' + (violatedRuleCount > 1 ? 's' : ''));
+
+        var errorPrompts = generateRuleHandlingPrompts(errorList);
+
+        return this._getUserViolationChoices(errorPrompts)
+        .then(this._handleViolatedRules.bind(this, errorPrompts, errorList))
+        .then(function() {
+            return this._config;
+        }.bind(this));
+    }.bind(this))
+    .then(function flushConfig(config) {
+        fs.writeFileSync(process.cwd() + '/.jscsrc', JSON.stringify(this._config, null, '\t'));
+        console.log('Generated a .jscsrc configuration file in ' + process.cwd());
+    }.bind(this));
+};
+
+/**
+ * @private
+ * @param  {Object[][]} resultsPerPreset - List of error objects for each preset's run of checkPath
+ * @param  {String[]} presetNames
+ * @return {Object[]} Aggregated datapoints for each preset
+ */
+Generator.prototype._generateStatsForPresets = function(resultsPerPreset, presetNames) {
+    return resultsPerPreset.map(function(presetResults, idx) {
+        var errorCollection = [].concat.apply([], presetResults);
+
+        var presetStats = {
+            name: presetNames[idx],
+            sum: 0,
+            errors: []
+        };
+
+        errorCollection.forEach(function(error) {
+            presetStats.sum += error.getErrorCount();
+            presetStats.errors = presetStats.errors.concat(error.getErrorList());
+        });
+
+        return presetStats;
+    });
+};
+
+/**
+ * @private
+ * @param  {Object[]} statsForPresets
+ */
+Generator.prototype._showErrorCounts = function(statsForPresets) {
+    var table = getTable();
+
+    statsForPresets.forEach(function(presetStats, idx) {
+        table.push([idx + 1, presetStats.name, presetStats.sum]);
+    });
+
+    console.log(table.toString());
+};
+
+/**
+ * Prompts the user to choose a preset
+ *
+ * @private
+ * @param {Object} prompt
+ * @return {Promise}
+ */
+Generator.prototype._getUserPresetChoice = function(prompt) {
+    return this._showPrompt(prompt);
+};
+
+/**
+ * Prompts the user to nullify rules or fix violations themselves
+ *
+ * @private
+ * @param  {Object[]} errorPrompts
+ * @return {Promise}
+ */
+Generator.prototype._getUserViolationChoices = function(errorPrompts) {
+    return this._showPrompt(errorPrompts);
+};
+
+function promisify(fn) {
+    return function() {
+        var deferred = Vow.defer();
+        var args = [].slice.call(arguments);
+
+        args.push(function(err, result) {
+            if (err) {
+                deferred.reject(err);
+            } else {
+                deferred.resolve(result);
+            }
+        });
+
+        fn.apply(null, args);
+
+        return deferred.promise();
+    };
+}
+
+/** @private */
+Generator.prototype._showPrompt = promisify(prompt.get.bind(prompt));
+
+/**
+ * @private
+ * @param  {Object[]} errorPrompts
+ * @param  {String[]} errorList
+ * @param  {Object[]} choices
+ */
+Generator.prototype._handleViolatedRules = function(errorPrompts, errorList, choices) {
+    errorPrompts.forEach(function(errorPrompt, idx) {
+        var associatedRuleName = errorList[idx];
+        var userChoice = choices[errorPrompt.name];
+
+        if (userChoice.toLowerCase() === 'e') {
+            this._config[associatedRuleName] = null;
+        }
+    }, this);
+};
+
+/**
+ * @private
+ * @param  {String} path
+ * @param  {String} presetName
+ * @return {Promise}
+ */
+Generator.prototype._checkAgainstPreset = function(path, presetName) {
+    var checker = getChecker();
+
+    checker.configure({preset: presetName});
+
+    return checker.checkPath(path);
+};
+
+/**
+ * @private
+ * @return {lib/Checker}
+ */
+function getChecker() {
+    var checker = new Checker();
+    checker.registerDefaultRules();
+    return checker;
+}
+
+/**
+ * @private
+ * @param  {String[]} violatedRuleNames
+ * @return {Object[]}
+ */
+function generateRuleHandlingPrompts(violatedRuleNames) {
+    return violatedRuleNames.map(function(ruleName) {
+        var prompt = assign({}, prompts[1]);
+        prompt.name = colors.green(ruleName) + ': ' + prompt.name;
+        return prompt;
+    });
+}
+
+/**
+ * @private
+ * @param  {Object[]} errorsList
+ * @return {String[]}
+ */
+function getUniqueErrorNames(errorsList) {
+    var errorNameLUT = {};
+
+    errorsList.forEach(function(error) {
+        errorNameLUT[error.rule] = true;
+    });
+
+    return Object.keys(errorNameLUT);
+}
+
+/**
+ * @private
+ * @return {Object}
+ */
+function getTable() {
+    return new Table({
+        chars: {
+            top: '', 'top-mid': '', 'top-left': '', 'top-right': '',
+            bottom: '', 'bottom-mid': '', 'bottom-left': '', 'bottom-right': '',
+            left: '', 'left-mid': '',
+            mid: '', 'mid-mid': '',
+            right: '', 'right-mid': '' ,
+            middle: ' '
+        },
+        style: {
+            'padding-left': 0,
+            'padding-right': 0
+        },
+        head: ['', 'Preset', '#Errors']
+    });
+}
+
+module.exports = Generator;

lib/config/node-configuration.js

@@ -1,5 +1,6 @@
 var path = require('path');
 var util = require('util');
+var utils = require('../utils');
 var glob = require('glob');
 var Configuration = require('./configuration');
 var assert = require('assert');
@@ -51,10 +52,7 @@ NodeConfiguration.prototype.overrideFromCLI = function(program) {
  */
 NodeConfiguration.prototype._loadPlugin = function(plugin) {
     if (typeof plugin === 'string') {
-        var pluginPath = plugin;
-        if (isRelativeRequirePath(pluginPath)) {
-            pluginPath = path.resolve(this._basePath, pluginPath);
-        }
+        var pluginPath = utils.normalizePath(plugin, this._basePath);
         plugin = require(pluginPath);
     }
     Configuration.prototype._loadPlugin.call(this, plugin);
@@ -73,9 +71,7 @@ NodeConfiguration.prototype._loadErrorFilter = function(errorFilter) {
     );
 
     if (errorFilter) {
-        if (isRelativeRequirePath(errorFilter)) {
-            errorFilter = path.resolve(this._basePath, errorFilter);
-        }
+        errorFilter = utils.normalizePath(errorFilter, this._basePath);
         errorFilter = require(errorFilter);
     }
 
@@ -95,9 +91,7 @@ NodeConfiguration.prototype._loadEsprima = function(esprima) {
     );
 
     if (esprima) {
-        if (isRelativeRequirePath(esprima)) {
-            esprima = path.resolve(this._basePath, esprima);
-        }
+        esprima = utils.normalizePath(esprima, this._basePath);
         esprima = require(esprima);
     }
 
@@ -121,10 +115,4 @@ NodeConfiguration.prototype._loadAdditionalRule = function(additionalRule) {
     }
 };
 
-function isRelativeRequirePath(requirePath) {
-    // Logic from: https://github.com/joyent/node/blob/4f1ae11a62b97052bc83756f8cb8700cc1f61661/lib/module.js#L237
-    var start = requirePath.substring(0, 2);
-    return start === './' || start === '..';
-}
-
 module.exports = NodeConfiguration;