lesslint/lib/rule/shorthand.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）使用 #RRGGBB 格式定义，并在可能时尽量（SHOULD）缩写为 #RGB 形式，且避免直接使用颜色名称与 rgb() 表达式。
 *       https://github.com/ecomfe/spec/blob/master/less-code-style.md#%E9%A2%9C%E8%89%B2
 * @author ielgnaw(wuji0223@gmail.com)
 */

var RULENAME = 'hex-color';

/**
 * 判断颜色值是否可以缩写
 *
 * @const
 * @type {RegExp}
 */
var PATTERN_COLOR = /#([\da-f])\1([\da-f])\2([\da-f])\3/i;

/**
 * 错误信息
 *
 * @const
 * @type {string}
 */
var MSG = 'Color value can be abbreviated, must use the abbreviation form';

/**
 * 行数的缓存，避免相同的行报多次，因为这里是直接按照 value 值整体来报的
 */
var lineCache = 0;

/**
 * 具体的检测逻辑
 *
 * @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;
        }

        lineCache = 0;

        if (realRuleVal.indexOf('color') > -1) {

            css.walkDecls(function (decl) {
                var value = decl.value,
                    source = decl.source;

                var parts = _postcss2.default.list.space(value);
                for (var i = 0, len = parts.length; i < len; i++) {
                    var part = parts[i];
                    if (PATTERN_COLOR.test(part)) {
                        if (lineCache === source.start.line) {
                            continue;
                        }

                        var line = source.start.line;
                        lineCache = line;
                        var lineContent = (0, _util.getLineContent)(line, source.input.css, true);
                        var col = source.start.column + decl.prop.length + decl.raws.between.length;
                        result.warn(RULENAME, {
                            node: decl,
                            ruleName: RULENAME,
                            line: line,
                            col: col,
                            message: MSG,
                            colorMessage: '`' + (0, _util.changeColorByStartAndEndIndex)(lineContent, col, source.end.column) + '` ' + _chalk2.default.grey(MSG)
                        });
                    }
                }
            });
        }
    };
});
//# sourceMappingURL=data:application/json;charset=utf-8;base64,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