validateIndentation: exception to indentation rules for module pattern

Fixes #436
Closes gh-981

Author: mikesherov

lib/rules/validate-indentation.js

@@ -86,6 +86,7 @@
  */
 
 var assert = require('assert');
+var utils = require('../utils');
 
 var blockParents = [
     'IfStatement',
@@ -100,6 +101,15 @@ var blockParents = [
     'CatchClause',
 ];
 
+var indentableNodes = {
+    BlockStatement: 'body',
+    Program: 'body',
+    ObjectExpression: 'properties',
+    ArrayExpression: 'elements',
+    SwitchStatement: 'cases',
+    SwitchCase: 'consequent'
+};
+
 module.exports = function() {};
 
 module.exports.prototype = {
@@ -128,15 +138,7 @@ module.exports.prototype = {
         }
 
         this._breakIndents = null;
-
-        this._indentableNodes = {
-            BlockStatement: 'body',
-            Program: 'body',
-            ObjectExpression: 'properties',
-            ArrayExpression: 'elements',
-            SwitchStatement: 'cases',
-            SwitchCase: 'consequent'
-        };
+        this._moduleIndents = null;
     },
 
     getOptionName: function() {
@@ -327,12 +329,54 @@ module.exports.prototype = {
             });
         }
 
+        function setModuleBody(node) {
+            if (node.body.length !== 1 || node.body[0].type !== 'ExpressionStatement' ||
+                node.body[0].expression.type !== 'CallExpression') {
+                return;
+            }
+
+            var callExpression = node.body[0].expression;
+            var callee = callExpression.callee;
+            var callArgs = callExpression.arguments;
+            var iffeFunction = utils.getFunctionNodeFromIIFE(callExpression);
+
+            if (iffeFunction) {
+                if (callArgs.length === 1 && callArgs[0].type === 'FunctionExpression') {
+                    // detect UMD Shim, where the file body is the body of the factory,
+                    // which is the sole argument to the IIFE
+                    moduleBody = callArgs[0].body;
+                } else {
+                    // full file IIFE
+                    moduleBody = iffeFunction.body;
+                }
+            }
+
+            // detect require/define
+            if (callee.type === 'Identifier' && callee.name.match(/^(require|define)$/)) {
+                // the define callback is the *first* functionExpression encountered,
+                // as it can be the first, second, or third argument.
+                callArgs.some(function(argument) {
+                    if (argument.type === 'FunctionExpression') {
+                        moduleBody = argument.body;
+                        return true;
+                    }
+                });
+            }
+
+            // set number of indents for modules by detecting
+            // whether the first statement is indented or not
+            if (moduleBody) {
+                _this._moduleIndents = moduleBody.body[0].loc.start.column > 0 ? 1 : 0;
+            }
+        }
+
         function generateIndentations() {
             file.iterateNodesByType('Program', function(node) {
                 if (!isMultiline(node)) {
                     return;
                 }
 
+                setModuleBody(node);
                 markChildren(node);
             });
 
@@ -341,9 +385,11 @@ module.exports.prototype = {
                     return;
                 }
 
+                var indents = node === moduleBody ? _this._moduleIndents : 1;
+
                 markChildren(node);
-                markPop(node, 1);
-                markPush(getBlockNodeToPush(node), 1);
+                markPop(node, indents);
+                markPush(getBlockNodeToPush(node), indents);
                 markEndCheck(node);
             });
 
@@ -410,7 +456,8 @@ module.exports.prototype = {
 
         var _this = this;
 
-        var indentableNodes = this._indentableNodes;
+        var moduleBody;
+
         var indentChar = this._indentChar;
         var indentSize = this._indentSize;
 

lib/utils.js

@@ -146,6 +146,35 @@ exports.isSnakeCased = function(name) {
     return SNAKE_CASE_RE.test(name);
 };
 
+/**
+ * Returns the function expression node if the provided node is an iffe,
+ * other returns undefined.
+ *
+ * @param  {Object} node
+ * @return {?Object}
+ */
+exports.getFunctionNodeFromIIFE = function(node) {
+    if (node.type !== 'CallExpression') {
+        return null;
+    }
+
+    var callee = node.callee;
+
+    if (callee.type === 'FunctionExpression') {
+        return callee;
+    }
+
+    if (callee.type === 'MemberExpression' &&
+        callee.object.type === 'FunctionExpression' &&
+        callee.property.type === 'Identifier' &&
+        (callee.property.name === 'call' || callee.property.name === 'apply')
+    ) {
+        return callee.object;
+    }
+
+    return null;
+};
+
 /**
  * Trims leading and trailing underscores
  *

test/rules/validate-indentation.js

@@ -150,6 +150,67 @@ describe('rules/validate-indentation', function() {
         });
     });
 
+    describe('module pattern indentation', function() {
+        beforeEach(function() {
+            checker.configure({ validateIndentation: 4 });
+        });
+
+        var cases = {
+            'no indentation': 'a++;',
+            indentation: '    a++;'
+        };
+
+        Object.keys(cases).forEach(function(title) {
+            var statement = cases[title];
+
+            it('should allow ' + title + ' in UMD Shim', function() {
+                var source = '\n' +
+                '(function( factory ) {\n' +
+                '    if ( typeof define === "function" && define.amd ) {\n' +
+                '        define(factory);\n' +
+                '    } else {\n' +
+                '        factory();\n' +
+                '    }\n' +
+                '}(function( $ ) {\n' +
+                statement + '\n' +
+                '}));';
+                assert(checker.checkString(source).isEmpty());
+            });
+
+            it('should allow ' + title + ' in define', function() {
+                var source = '\n' +
+                'define(["dep"], function( dep ) {\n' +
+                statement + '\n' +
+                '});';
+                assert(checker.checkString(source).isEmpty());
+            });
+
+            it('should allow ' + title + ' in require', function() {
+                var source = '\n' +
+                'require(["dep"], function( dep ) {\n' +
+                statement + '\n' +
+                '});';
+                assert(checker.checkString(source).isEmpty());
+            });
+
+            it('should allow ' + title + ' in full file IIFE', function() {
+                var source = '\n' +
+                '(function(global) {\n' +
+                statement + '\n' +
+                '}(this));';
+                assert(checker.checkString(source).isEmpty());
+            });
+        });
+
+        it('should not allow no indentation in some other top level function', function() {
+            var source = '\n' +
+            'defines(["dep"], function( dep ) {\n' +
+            'a++;\n' +
+            '});';
+            assert(!checker.checkString(source).isEmpty());
+        });
+    });
+
     describe('switch identation', function() {
         beforeEach(function() {
             checker.configure({ validateIndentation: 4 });

test/utils.js

@@ -1,7 +1,18 @@
 var utils = require('../lib/utils');
 var assert = require('assert');
+var JsFile = require('../lib/js-file');
+var esprima = require('esprima');
 
 describe('modules/utils', function() {
+
+    function createJsFile(source) {
+        return new JsFile(
+            'example.js',
+            source,
+            esprima.parse(source, {loc: true, range: true, comment: true, tokens: true})
+        );
+    }
+
     describe('isEs3Keyword', function() {
         it('should return true for ES3 keywords', function() {
             assert(utils.isEs3Keyword('break'));
@@ -60,6 +71,46 @@ describe('modules/utils', function() {
         });
     });
 
+    describe('getFunctionNodeFromIIFE', function() {
+        it('should return the function from simple IIFE', function() {
+            var file = createJsFile('var a = function(){a++;}();');
+            var callExpression = file.getNodesByType('CallExpression')[0];
+            var functionExpression = file.getNodesByType('FunctionExpression')[0];
+
+            assert.equal(utils.getFunctionNodeFromIIFE(callExpression), functionExpression);
+        });
+
+        it('should return the function from call()\'ed IIFE', function() {
+            var file = createJsFile('var a = function(){a++;}.call();');
+            var callExpression = file.getNodesByType('CallExpression')[0];
+            var functionExpression = file.getNodesByType('FunctionExpression')[0];
+
+            assert.equal(utils.getFunctionNodeFromIIFE(callExpression), functionExpression);
+        });
+
+        it('should return the function from apply()\'ed IIFE', function() {
+            var file = createJsFile('var a = function(){a++;}.apply();');
+            var callExpression = file.getNodesByType('CallExpression')[0];
+            var functionExpression = file.getNodesByType('FunctionExpression')[0];
+
+            assert.equal(utils.getFunctionNodeFromIIFE(callExpression), functionExpression);
+        });
+
+        it('should return undefined for non callExpressions', function() {
+            var file = createJsFile('var a = 1;');
+            var notCallExpression = file.getNodesByType('VariableDeclaration')[0];
+
+            assert.equal(utils.getFunctionNodeFromIIFE(notCallExpression), undefined);
+        });
+
+        it('should return undefined for normal function calls', function() {
+            var file = createJsFile('call();');
+            var callExpression = file.getNodesByType('CallExpression')[0];
+
+            assert.equal(utils.getFunctionNodeFromIIFE(callExpression), undefined);
+        });
+    });
+
     describe('trimUnderscores', function() {
         it('should trim trailing underscores', function() {
             assert.equal(utils.trimUnderscores('__snake_cased'), 'snake_cased');