lesslint/lib/rule/require-newline.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）独占一行。
 *       https://github.com/ecomfe/spec/blob/master/less-code-style.md#%E9%80%89%E6%8B%A9%E5%99%A8
 * @author ielgnaw(wuji0223@gmail.com)
 */

var RULENAME = 'require-newline';

/**
 * 判断逗号后面没有跟着换行符的正则
 * 如果未匹配，则说明逗号后面有换行符
 *
 * @const
 * @type {RegExp}
 */
var PATTERN_NOTLF = /(,(?!\s*\n))/;

/**
 * 错误信息
 *
 * @const
 * @type {string}
 */
var MSG = 'When multiple selectors share a statement block, each selector statement must be per line';

/**
 * 具体的检测逻辑
 *
 * @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) {
        var ruleVal = opts.ruleVal;
        var realRuleVal = [];

        Array.prototype.push[Array.isArray(ruleVal) ? 'apply' : 'call'](realRuleVal, ruleVal);

        if (!realRuleVal.length) {
            return;
        }

        if (realRuleVal.indexOf('selector') > -1) {
            css.walkRules(function (rule) {
                var selector = rule.selector;
                if (!rule.ruleWithoutBody // 排除 mixin 调用
                && !rule.params // 排除 mixin 定义
                && PATTERN_NOTLF.test(selector)) {
                    var source = rule.source;
                    var line = source.start.line;
                    var lineContent = (0, _util.getLineContent)(line, source.input.css);
                    var col = source.start.column;
                    // 如果是 `p, i, \n.cc` 这样的选择器，那么高亮就应该把后面的 `\n.cc` 去掉
                    // 直接用 lineContent 来匹配 `p, i, \n.cc` 无法高亮
                    var colorStr = selector.replace(/\n.*/, '');
                    result.warn(RULENAME, {
                        node: rule,
                        ruleName: RULENAME,
                        line: line,
                        col: col,
                        message: MSG,
                        colorMessage: '`' + lineContent.replace(colorStr, _chalk2.default.magenta(colorStr)) + '` ' + _chalk2.default.grey(MSG)
                    });
                }
            });
        }
    };
});
//# sourceMappingURL=data:application/json;charset=utf-8;base64,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