eslint-plugin-lodash/lib/rules/chain-style.js

Lodash specific linting rules for ESLint

/**
 * @fileoverview Rule to enforce a specific chain style
 */
'use strict';

/**
 * @fileoverview Rule to enforce a specific chain style
 */
//------------------------------------------------------------------------------
// Rule Definition
//------------------------------------------------------------------------------

module.exports = {
    meta: {
        schema: [{
            enum: ['as-needed', 'implicit', 'explicit']
        }]
    },

    create: function create(context) {
        var _require = require('../util/lodashUtil');

        var isChainable = _require.isChainable;
        var isChainBreaker = _require.isChainBreaker;
        var isExplicitChainStart = _require.isExplicitChainStart;
        var isImplicitChainStart = _require.isImplicitChainStart;
        var getLodashImportVisitors = _require.getLodashImportVisitors;

        var _require2 = require('../util/astUtil');

        var isMethodCall = _require2.isMethodCall;

        var settings = require('../util/settingsUtil').getSettings(context);

        var _require3 = require('../util/ruleUtil');

        var combineVisitorObjects = _require3.combineVisitorObjects;

        var callExpressionVisitors = {
            'as-needed': function asNeeded(node) {
                if (isExplicitChainStart(node, settings.pragma, context)) {
                    var curr = node.parent.parent;
                    var needed = false;
                    while (isMethodCall(curr) && !isChainBreaker(curr, settings.version)) {
                        if (!isChainable(curr, settings.version) && !isChainBreaker(curr.parent.parent, settings.version)) {
                            needed = true;
                        }
                        curr = curr.parent.parent;
                    }
                    if (isMethodCall(curr) && !needed) {
                        context.report(node, 'Unnecessary explicit chaining');
                    }
                }
            },
            implicit: function implicit(node) {
                if (isExplicitChainStart(node, settings.pragma, context)) {
                    context.report(node, 'Do not use explicit chaining');
                }
            },
            explicit: function explicit(node) {
                if (isImplicitChainStart(node, settings.pragma, context)) {
                    context.report(node, 'Do not use implicit chaining');
                }
            }
        };

        return combineVisitorObjects({
            CallExpression: callExpressionVisitors[context.options[0] || 'as-needed']
        }, getLodashImportVisitors(context));
    }
};