Configuration: small refactoring of the configuration module

Ref #1083
Ref #109

lib/config/configuration.js

@@ -60,23 +60,8 @@ Configuration.prototype.load = function(config) {
     copyConfiguration(overrides, currentConfig);
 
     var ruleSettings = this._processConfig(currentConfig);
-    var processedSettings = {};
 
-    Object.keys(ruleSettings).forEach(function(optionName) {
-        var rule = this._rules[optionName];
-        if (rule) {
-            var optionValue = ruleSettings[optionName];
-            if (optionValue !== null) {
-                rule.configure(ruleSettings[optionName]);
-                this._configuredRules.push(rule);
-                processedSettings[optionName] = ruleSettings[optionName];
-            }
-        } else {
-            this._unsupportedRuleNames.push(optionName);
-        }
-    }, this);
-
-    this._ruleSettings = processedSettings;
+    this._loadRules(ruleSettings);
 };
 
 /**
@@ -285,19 +270,6 @@ Configuration.prototype._processConfig = function(config) {
         options.plugins.forEach(this._loadPlugin, this);
     }
 
-    // Apply presets
-    var presetName = options.preset;
-    if (presetName) {
-        this._presetName = presetName;
-        assert(typeof presetName === 'string', '`preset` option requires string value');
-        var presetData = this._presets[presetName];
-        assert(Boolean(presetData), 'Preset "' + presetName + '" does not exist');
-        var presetResult = this._processConfig(presetData);
-        Object.keys(presetResult).forEach(function(key) {
-            ruleSettings[key] = presetResult[key];
-        });
-    }
-
     // File extensions
     if (options.fileExtensions) {
         assert(
@@ -367,6 +339,11 @@ Configuration.prototype._processConfig = function(config) {
         this._loadVerbose(options.verbose);
     }
 
+    // Apply presets
+    if (options.hasOwnProperty('preset')) {
+        this._loadPreset(options.preset);
+    }
+
     // NOTE: rule setting must come last in order to
     // override any rules that are loaded from a preset
     Object.keys(config).forEach(function(key) {
@@ -389,6 +366,30 @@ Configuration.prototype._loadPlugin = function(plugin) {
     plugin(this);
 };
 
+/**
+ * Load rules.
+ * @param {Object} ruleSettings
+ * @protected
+ */
+Configuration.prototype._loadRules = function(ruleSettings) {
+    Object.keys(ruleSettings).forEach(function(optionName) {
+        var rule = this._rules[optionName];
+        if (rule) {
+            var optionValue = ruleSettings[optionName];
+            if (optionValue !== null) {
+                rule.configure(ruleSettings[optionName]);
+                this._configuredRules.push(rule);
+
+                this._ruleSettings[optionName] = ruleSettings[optionName]
+            }
+        } else {
+            if (!~this._unsupportedRuleNames.indexOf(optionName)) {
+                this._unsupportedRuleNames.push(optionName);
+            }
+        }
+    }, this);
+}
+
 /**
  * Loads an error filter.
  *
@@ -433,6 +434,25 @@ Configuration.prototype._loadEsprima = function(esprima) {
     this._esprima = esprima;
 };
 
+/**
+ * Loads preset.
+ *
+ * @param {Object} preset
+ * @protected
+ */
+Configuration.prototype._loadPreset = function(preset) {
+    if (!this._presetName) {
+        this._presetName = preset;
+    }
+    assert(typeof preset === 'string', '`preset` option requires string value');
+
+    var presetData = this._presets[preset];
+    assert(Boolean(presetData), 'Preset "' + preset + '" does not exist');
+
+    var ruleSettings = this._processConfig(this._presets[preset]);
+    this._loadRules(ruleSettings);
+};
+
 /**
  * Loads custom Esprima options.
  *

test/specs/config/configuration.js

@@ -340,10 +340,88 @@ describe('modules/config/configuration', function() {
         });
 
         it('should load `preset` options', function() {
-            configuration.registerPreset('preset', {maxErrors: 1});
-            configuration.load({preset: 'preset'});
-            assert(configuration.getProcessedConfig().preset === 'preset');
+            configuration.registerPreset('test', {maxErrors: 1});
+            configuration.load({preset: 'test'});
+            assert(configuration.getProcessedConfig().preset === 'test');
+            assert(configuration.getProcessedConfig().maxErrors === 1);
+        });
+
+        it('should load preset from the preset', function() {
+            configuration.registerDefaultRules();
+            configuration.registerPreset('test1', {
+                es3: true,
+                disallowMultipleVarDecl: true
+            });
+            configuration.registerPreset('test2', {
+                maxErrors: 1,
+                preset: 'test1',
+                disallowMultipleVarDecl: 'exceptUndefined'
+            });
+            configuration.load({
+                preset: 'test2'
+            });
+            assert(configuration.getProcessedConfig().preset === 'test2');
+            assert(configuration.getProcessedConfig().maxErrors === 1);
+            assert(configuration.getProcessedConfig().es3);
+            assert(configuration.getConfiguredRules()[0].exceptUndefined);
+        });
+
+        it('should not add duplicative values to list of unsupported rules', function() {
+            configuration.registerPreset('test1', {
+                es3: true,
+                disallowMultipleVarDecl: true
+            });
+            configuration.registerPreset('test2', {
+                maxErrors: 1,
+                preset: 'test1',
+                disallowMultipleVarDecl: 'exceptUndefined'
+            });
+            configuration.load({
+                preset: 'test2'
+            });
+            assert.equal(configuration.getUnsupportedRuleNames().length, 1);
+        });
+
+        it('should load preset from the preset with additional rule', function() {
+            var rule = {
+                getOptionName: function() {
+                    return 'ruleName';
+                },
+                configure: function() {}
+            };
+            configuration.registerPreset('test1', {
+                es3: true,
+                ruleName: "test",
+                additionalRules: [rule]
+            });
+            configuration.registerPreset('test2', {
+                maxErrors: 1,
+                preset: 'test1'
+            });
+
+            configuration.load({
+                preset: 'test2'
+            });
+
+            assert(configuration.getProcessedConfig().preset === 'test2');
             assert(configuration.getProcessedConfig().maxErrors === 1);
+            assert(configuration.getProcessedConfig().es3);
+            assert(configuration.getProcessedConfig().ruleName);
+            assert.equal(configuration.getUnsupportedRuleNames().length, 0);
+        });
+
+        it('should handle preset with custom rule which is not included', function() {
+            configuration.registerPreset('test', {
+                es3: true,
+                ruleName: "test",
+            });
+
+            configuration.load({
+                preset: 'test'
+            });
+
+            assert(configuration.getUnsupportedRuleNames()[ 0 ], 'ruleName')
+            assert(!('ruleName' in configuration.getProcessedConfig()));
         });
 
         it('should load `preset` rule settings', function() {