New rule: requireNewlineBeforeSingleStatementsInIf

Valid:
if (x)
    doX();
else
    doY();

Invalid:
if (x) doX();
else doY();

Fixes #1829
Closes gh-2138

Author: schempy

lib/config/configuration.js

@@ -1144,6 +1144,8 @@ Configuration.prototype.registerDefaultRules = function() {
     this.registerRule(require('../rules/require-aligned-multiline-params'));
 
     this.registerRule(require('../rules/require-early-return'));
+
+    this.registerRule(require('../rules/require-newline-before-single-statements-in-if'));
 };
 
 /**

lib/rules/require-newline-before-single-statements-in-if.js

@@ -0,0 +1,94 @@
+/**
+ * Requires newline before single if statements
+ *
+ * Type: `Boolean`
+ *
+ * Value: `true`
+ *
+ * #### Example
+ *
+ * ```js
+ * "requireNewlineBeforeSingleStatementsInIf": true
+ * ```
+ *
+ * ##### Valid
+ *
+ * ```js
+ * if (x)
+ *    doX();
+ * else
+ *    doY();
+ *
+ * if (x)
+ *    doX();
+ * else if (v)
+ *    doV();
+ * else
+ *    doY();
+ * ```
+ *
+ * ##### Invalid
+ *
+ * ```js
+ * if (x) doX();
+ * else doY();
+ *
+ * if (x) doX();
+ * else if (v) doV();
+ * else doY();
+ * ```
+ */
+
+var assert = require('assert');
+
+module.exports = function() {};
+
+module.exports.prototype = {
+
+    configure: function(value) {
+        assert(
+            value === true,
+            this.getOptionName() + ' option requires a true value or should be removed'
+        );
+    },
+
+    getOptionName: function() {
+        return 'requireNewlineBeforeSingleStatementsInIf';
+    },
+
+    check: function(file, errors) {
+        function isExpressionStatement(entity) {
+            return entity.type === 'ExpressionStatement';
+        }
+
+        function assertDifferentLine(token, nextToken) {
+            errors.assert.differentLine({
+              token: token,
+              nextToken: nextToken,
+              message: 'Newline before single statement in if is required'
+            });
+        }
+
+        // Recursively locate a token based on it's type.
+        function getToken(entity, tokenType, tokenProperty) {
+            if (entity.type === tokenType || !entity[tokenProperty]) {
+                return entity;
+            } else {
+                return getToken(entity[tokenProperty], tokenType, tokenProperty);
+            }
+        }
+
+        file.iterateNodesByType('IfStatement', function(node) {
+            var consequentNode = node.consequent;
+            var alternateNode = node.alternate;
+
+            if (isExpressionStatement(consequentNode)) {
+                assertDifferentLine(consequentNode, getToken(consequentNode, 'Keyword', 'previousSibling'));
+            }
+
+            if (isExpressionStatement(alternateNode)) {
+                assertDifferentLine(alternateNode, getToken(alternateNode, 'Keyword', 'previousSibling'));
+            }
+        });
+    }
+};

test/specs/rules/require-newline-before-single-statements-in-if.js

@@ -0,0 +1,45 @@
+var Checker = require('../../../lib/checker');
+var expect = require('chai').expect;
+
+describe('rules/require-newline-before-single-statements-in-if', function() {
+    var checker;
+
+    beforeEach(function() {
+        checker = new Checker();
+        checker.registerDefaultRules();
+    });
+
+    describe('value true', function() {
+        beforeEach(function() {
+            checker.configure({ requireNewlineBeforeSingleStatementsInIf: true });
+        });
+
+        it('should ignore if in a block statment', function() {
+            expect(checker.checkString('if (x) {\n doX();\n} else {\n doY();\n}')).to.have.no.errors();
+        });
+
+        it('should not report missing newline before conditional statement', function() {
+            expect(checker.checkString('if (x)\ndoX();\nelse \ndoY();\n')).to.have.no.errors();
+        });
+
+        it('should not report missing newline before conditional for nested else if', function() {
+            expect(checker.checkString('if (x)\ndoX();\nelse if (v)\ndoV();\nelse\ndoY();'))
+              .to.have.no.errors();
+        });
+
+        it('should report missing newline before conditional for consequent', function() {
+            expect(checker.checkString('if (x) doX();\nelse\n doY();'))
+              .to.have.one.validation.error.from('requireNewlineBeforeSingleStatementsInIf');
+        });
+
+        it('should report missing newline before conditional for alternate', function() {
+            expect(checker.checkString('if (x)\ndoX();\nelse doY();'))
+              .to.have.one.validation.error.from('requireNewlineBeforeSingleStatementsInIf');
+        });
+
+        it('should report missing newline before conditional for nested else if', function() {
+            expect(checker.checkString('if (x)\ndoX();\nelse if (v) doV();\nelse\ndoY();'))
+              .to.have.one.validation.error.from('requireNewlineBeforeSingleStatementsInIf');
+        });
+    });
+});