lesslint/lib/rule/block-indent.js

lint your less code

'use strict';

Object.defineProperty(exports, "__esModule", {
    value: true
});
exports.check = undefined;

var _chalk = require('chalk');

var _chalk2 = _interopRequireDefault(_chalk);

var _postcss = require('postcss');

var _postcss2 = _interopRequireDefault(_postcss);

var _util = require('../util');

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

'use strict';

/**
 * 规则名称
 *
 * @const
 * @type {string}
 */
/**
 * @file 缩进校验
 *       必须（MUST）采用 4 个空格为一次缩进， 不得（MUST NOT）采用 TAB 作为缩进。
 *       https://github.com/ecomfe/spec/blob/master/less-code-style.md#%E5%B5%8C%E5%A5%97%E5%92%8C%E7%BC%A9%E8%BF%9B
 * @author ielgnaw(wuji0223@gmail.com)
 */

var RULENAME = 'block-indent';

/**
 * 行号的缓存，防止同一行多次报错
 *
 * @type {number}
 */
var lineCache = 0;

/**
 * 获取错误信息
 *
 * @param {string} curIndent 当前的缩进（错误的）
 * @param {string} neededIndent 期望的的缩进（正确的）
 *
 * @return {string} 错误信息
 */
var getMsg = function getMsg(curIndent, neededIndent) {
    return '' + 'Bad indentation, Expected `' + neededIndent + '` but saw `' + curIndent + '`';
};

/**
 * 添加报错信息
 *
 * @param {Object} node node 对象，可能是 decl 也可能是 rule
 * @param {Object} result postcss 转换的结果对象
 * @param {string} msg 错误信息
 * @param {string} hackPrefixChar 属性 hack 的前缀，`_` 或者 `*`
 */
var addWarn = function addWarn(node, result, msg) {
    var hackPrefixChar = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : '';

    var source = node.source;
    var line = source.start.line;
    if (lineCache !== line) {
        lineCache = line;
        var col = source.start.column;

        var lineContent = (0, _util.getLineContent)(line, source.input.css) || '';
        var colorStr = '';

        if (node.selector) {
            colorStr = node.selector;
        } else if (node.type === 'atrule') {
            colorStr = lineContent;
        } else {
            colorStr = hackPrefixChar + node.prop + node.raws.between + node.value;
            colorStr = colorStr.replace(/\n/g, '');
        }

        result.warn(RULENAME, {
            node: node,
            ruleName: RULENAME,
            line: line,
            col: col,
            message: msg,
            colorMessage: '`' + lineContent.replace(colorStr, _chalk2.default.magenta(colorStr)) + '` ' + _chalk2.default.grey(msg)
        });
    }
};

/**
 * 遍历 ruleList，为了分析 decl
 *
 * @param {Array} ruleList rule 集合
 * @param {Object} result postcss 转换的结果对象
 */
var ruleListIterator = function ruleListIterator(ruleList, result) {
    ruleList.forEach(function (r) {
        var rule = r.node;
        var indentStr = r.indentStr;
        if (rule.nodes && rule.nodes.length) {
            // 属性要比它所属的选择器多一层缩进
            indentStr += '    ';
            rule.nodes.forEach(function (childNode) {
                if (childNode.type !== 'decl') {
                    return;
                }

                var curIndent = childNode.raws.before.replace(/\n*/, '').length;
                var neededIndent = indentStr.length;
                if (curIndent !== neededIndent) {
                    addWarn(childNode, result, getMsg(curIndent + 1, neededIndent + 1));
                }
            });
        }
    });
};

/**
 * 具体的检测逻辑
 *
 * @param {Object} opts 参数
 * @param {*} opts.ruleVal 当前规则具体配置的值
 * @param {string} opts.fileContent 文件内容
 * @param {string} opts.filePath 文件路径
 */
var check = exports.check = _postcss2.default.plugin(RULENAME, function (opts) {
    return function (css, result) {
        if (!opts.ruleVal) {
            return;
        }

        lineCache = 0;

        // 收集顶层变量定义
        css.walkDecls(function (decl) {
            if (decl.parent.type === 'root') {
                var curIndent = decl.raws.before.replace(/\n*/, '').length;
                var neededIndent = 0;
                if (curIndent !== neededIndent) {
                    addWarn(decl, result, getMsg(curIndent + 1, neededIndent + 1));
                }
            }
        });

        var ruleList = [];

        var analyzeIndent = function analyzeIndent(rule, indentStr) {
            if (rule.type !== 'rule') {
                return;
            }

            var curIndent = rule.raws.before.replace(/\n*/, '').length;
            var neededIndent = indentStr.length;
            if (curIndent !== neededIndent) {
                addWarn(rule, result, getMsg(curIndent + 1, neededIndent + 1));
            }

            ruleList.push({
                node: rule,
                indentStr: indentStr
            });

            if (rule.nodes && rule.nodes.length) {
                rule.nodes.forEach(function (r) {
                    analyzeIndent(r, indentStr + '    ');
                });
            }
        };

        // 收集顶层选择器
        css.walkRules(function (rule) {
            if (rule.parent.type === 'root') {
                analyzeIndent(rule, '');
            }
        });

        ruleListIterator(ruleList, result);
    };
});
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/rule/block-indent.js"],"names":["RULENAME","lineCache","getMsg","curIndent","neededIndent","addWarn","node","result","msg","hackPrefixChar","source","line","start","col","column","lineContent","input","css","colorStr","selector","type","prop","raws","between","value","replace","warn","ruleName","message","colorMessage","chalk","magenta","grey","ruleListIterator","ruleList","forEach","rule","r","indentStr","nodes","length","childNode","before","check","postcss","plugin","opts","ruleVal","walkDecls","decl","parent","analyzeIndent","push","walkRules"],"mappings":"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","file":"block-indent.js","sourcesContent":["/**\n * @file 缩进校验\n *       必须（MUST）采用 4 个空格为一次缩进， 不得（MUST NOT）采用 TAB 作为缩进。\n *       https://github.com/ecomfe/spec/blob/master/less-code-style.md#%E5%B5%8C%E5%A5%97%E5%92%8C%E7%BC%A9%E8%BF%9B\n * @author ielgnaw(wuji0223@gmail.com)\n */\n\nimport chalk from 'chalk';\nimport postcss from 'postcss';\nimport {getLineContent} from '../util';\n\n'use strict';\n\n/**\n * 规则名称\n *\n * @const\n * @type {string}\n */\nconst RULENAME = 'block-indent';\n\n/**\n * 行号的缓存，防止同一行多次报错\n *\n * @type {number}\n */\nlet lineCache = 0;\n\n/**\n * 获取错误信息\n *\n * @param {string} curIndent 当前的缩进（错误的）\n * @param {string} neededIndent 期望的的缩进（正确的）\n *\n * @return {string} 错误信息\n */\nconst getMsg = (curIndent, neededIndent) => ''\n    + 'Bad indentation, Expected `'\n    + (neededIndent)\n    + '` but saw `'\n    + (curIndent)\n    + '`';\n\n/**\n * 添加报错信息\n *\n * @param {Object} node node 对象，可能是 decl 也可能是 rule\n * @param {Object} result postcss 转换的结果对象\n * @param {string} msg 错误信息\n * @param {string} hackPrefixChar 属性 hack 的前缀，`_` 或者 `*`\n */\nconst addWarn = (node, result, msg, hackPrefixChar = '') => {\n    const source = node.source;\n    const line = source.start.line;\n    if (lineCache !== line) {\n        lineCache = line;\n        const col = source.start.column;\n\n        let lineContent = getLineContent(line, source.input.css) || '';\n        let colorStr = '';\n\n        if (node.selector) {\n            colorStr = node.selector;\n        }\n        else if (node.type === 'atrule') {\n            colorStr = lineContent;\n        }\n        else {\n            colorStr = hackPrefixChar + node.prop + node.raws.between + node.value;\n            colorStr = colorStr.replace(/\\n/g, '');\n        }\n\n        result.warn(RULENAME, {\n            node: node,\n            ruleName: RULENAME,\n            line: line,\n            col: col,\n            message: msg,\n            colorMessage: '`'\n                + lineContent.replace(\n                    colorStr,\n                    chalk.magenta(colorStr)\n                )\n                + '` '\n                + chalk.grey(msg)\n        });\n    }\n};\n\n/**\n * 遍历 ruleList，为了分析 decl\n *\n * @param {Array} ruleList rule 集合\n * @param {Object} result postcss 转换的结果对象\n */\nconst ruleListIterator = (ruleList, result) => {\n    ruleList.forEach(r => {\n        const rule = r.node;\n        let indentStr = r.indentStr;\n        if (rule.nodes && rule.nodes.length) {\n            // 属性要比它所属的选择器多一层缩进\n            indentStr += '    ';\n            rule.nodes.forEach(childNode => {\n                if (childNode.type !== 'decl') {\n                    return;\n                }\n\n                const curIndent = childNode.raws.before.replace(/\\n*/, '').length;\n                const neededIndent = indentStr.length;\n                if (curIndent !== neededIndent) {\n                    addWarn(childNode, result, getMsg(curIndent + 1, neededIndent + 1));\n                }\n            });\n        }\n    });\n};\n\n/**\n * 具体的检测逻辑\n *\n * @param {Object} opts 参数\n * @param {*} opts.ruleVal 当前规则具体配置的值\n * @param {string} opts.fileContent 文件内容\n * @param {string} opts.filePath 文件路径\n */\nexport const check = postcss.plugin(RULENAME, opts =>\n    (css, result) => {\n        if (!opts.ruleVal) {\n            return;\n        }\n\n        lineCache = 0;\n\n        // 收集顶层变量定义\n        css.walkDecls(decl => {\n            if (decl.parent.type === 'root') {\n                let curIndent = decl.raws.before.replace(/\\n*/, '').length;\n                const neededIndent = 0;\n                if (curIndent !== neededIndent) {\n                    addWarn(decl, result, getMsg(curIndent + 1, neededIndent + 1));\n                }\n            }\n        });\n\n        const ruleList = [];\n\n        const analyzeIndent = (rule, indentStr) => {\n            if (rule.type !== 'rule') {\n                return;\n            }\n\n            let curIndent = rule.raws.before.replace(/\\n*/, '').length;\n            const neededIndent = indentStr.length;\n            if (curIndent !== neededIndent) {\n                addWarn(rule, result, getMsg(curIndent + 1, neededIndent + 1));\n            }\n\n            ruleList.push({\n                node: rule,\n                indentStr: indentStr\n            });\n\n            if (rule.nodes && rule.nodes.length) {\n                rule.nodes.forEach(r => {\n                    analyzeIndent(r, indentStr + '    ');\n                });\n            }\n        };\n\n        // 收集顶层选择器\n        css.walkRules(rule => {\n            if (rule.parent.type === 'root') {\n                analyzeIndent(rule, '');\n            }\n        });\n\n        ruleListIterator(ruleList, result);\n\n    }\n);\n"]}