jscs/lib/rules/require-multiple-var-decl.js

JavaScript Code Style

/**
 * Requires multiple `var` declaration.
 *
 * Types: `Boolean` or `String` or `Object`
 *
 * Values: `true` or `"onevar"` or `allExcept: ['require']`
 *
 * If `requireMultipleVarDecl` defined as a `true` value, it will report only consecutive vars, if, on the other hand,
 * value equals to `"onevar"` string, `requireMultipleVarDecl` will allow only one `var` per function scope.
 *
 * If the value is `allExcept: ['require']`, then require statements are allowed to have a var declaration per variable.
 *
 * JSHint: [`onevar`](http://jshint.com/docs/options/#onevar)
 *
 * #### Example
 *
 * ```js
 * "requireMultipleVarDecl": true
 * ```
 *
 * ##### Valid
 *
 * ```js
 * var x = 1,
 *     y = 2;
 * ```
 *
 * ##### Valid for `allExcept: ['require']`
 *
 * ```js
 * var a = require("a");
 * var b = require("b");
 * var c = 1,
 *     d = 2;
 * ```
 *
 * ##### Invalid
 *
 * ```js
 * var x = 1;
 * var y = 2;
 * ```
 */

var assert = require('assert');

function consecutive(file, errors) {
    var isExceptRequire = this._isExceptRequire;

    file.iterateNodesByType('VariableDeclaration', function(node) {
        if (isExceptRequire && hasRequireStatements(node)) {
            return;
        }

        var sibling = node.nextSibling;

        if (!sibling) {
            return;
        }

        while (sibling.nextSibling) {
            sibling = sibling.nextSibling;

            if (sibling.type !== node.type) {
                break;
            }

            if (isExceptRequire && hasRequireStatements(sibling)) {
                break;
            }

            if (sibling.kind === node.kind) {
                errors.add(
                    node.kind[0].toUpperCase() + node.kind.slice(1) + ' declarations should be joined',
                    sibling
                );
            }
        }
    });
}

function _onevar(file, errors, node) {
    var firstVar = true;
    var firstConst = true;
    var firstParent = true;

    file.iterate(function(node) {
        var type = node.type;
        var kind = node.kind;

        // Don't go in nested scopes
        if (!firstParent && ['FunctionDeclaration', 'FunctionExpression'].indexOf(type) > -1) {
            return false;
        }

        if (firstParent) {
            firstParent = false;
        }

        if (type === 'VariableDeclaration') {
            if (kind === 'var') {
                if (!firstVar) {
                    errors.add('Var declarations should be joined', node);

                } else {
                    firstVar = false;
                }
            }

            if (kind === 'const') {
                if (!firstConst) {
                    errors.add('Const declarations should be joined', node);

                } else {
                    firstConst = false;
                }
            }
        }
    }, node);
}

function onevar(file, errors) {
    _onevar(file, errors, file.getProgram());
    file.iterateNodesByType(
        ['FunctionDeclaration', 'FunctionExpression'],
        _onevar.bind(this, file, errors)
    );
}

function hasRequireStatements(node) {
    if (!Array.isArray(node.declarations)) {
        return false;
    }

    return node.declarations.some(function(declaration) {
        var init = declaration.init;

        return init &&
            init.callee &&
            init.callee.name === 'require';
    });
}

module.exports = function() {};

module.exports.prototype = {
    configure: function(options) {
        var isExceptRequire = typeof options === 'object' &&
                              options.allExcept.length &&
                              options.allExcept.indexOf('require') !== -1;

        assert(
            options === true ||
            options === 'onevar' ||
            isExceptRequire,
            this.getOptionName() + ' option requires a true value, `onevar` or {allExcept: [\'require\']}'
        );

        var checkers = {
            'true': consecutive,
            onevar: onevar
        };

        this._isExceptRequire = isExceptRequire;
        this._check = isExceptRequire ? consecutive : checkers[options];
    },

    getOptionName: function() {
        return 'requireMultipleVarDecl';
    },

    check: function() {
        return this._check.apply(this, arguments);
    }
};