| "use strict"; |
| |
| const isStandardSyntaxRule = require("../utils/isStandardSyntaxRule"); |
| const parseSelector = require("../utils/parseSelector"); |
| const report = require("../utils/report"); |
| |
| module.exports = function(opts) { |
| let hasFixed; |
| |
| opts.root.walkRules(rule => { |
| if (!isStandardSyntaxRule(rule)) { |
| return; |
| } |
| |
| hasFixed = false; |
| const selector = rule.raws.selector |
| ? rule.raws.selector.raw |
| : rule.selector; |
| |
| const fixedSelector = parseSelector( |
| selector, |
| opts.result, |
| rule, |
| selectorTree => { |
| selectorTree.walkCombinators(node => { |
| // Ignore spaced descendant combinator |
| if (/\s/.test(node.value)) { |
| return; |
| } |
| |
| // Check the exist of node in prev of the combinator. |
| // in case some that aren't the first begin with combinators (nesting syntax) |
| if (opts.locationType === "before" && !node.prev()) { |
| return; |
| } |
| |
| const parentParentNode = node.parent && node.parent.parent; |
| |
| // Ignore pseudo-classes selector like `.foo:nth-child(2n + 1) {}` |
| if (parentParentNode && parentParentNode.type === "pseudo") { |
| return; |
| } |
| |
| const sourceIndex = node.sourceIndex; |
| const index = |
| node.value.length > 1 && opts.locationType === "before" |
| ? sourceIndex |
| : sourceIndex + node.value.length - 1; |
| |
| check(selector, node, index, rule, sourceIndex); |
| }); |
| } |
| ); |
| |
| if (hasFixed) { |
| if (!rule.raws.selector) { |
| rule.selector = fixedSelector; |
| } else { |
| rule.raws.selector.raw = fixedSelector; |
| } |
| } |
| }); |
| |
| function check(source, combinator, index, node, sourceIndex) { |
| opts.locationChecker({ |
| source, |
| index, |
| errTarget: combinator.value, |
| err: m => { |
| if (opts.fix && opts.fix(combinator)) { |
| hasFixed = true; |
| |
| return; |
| } |
| |
| report({ |
| message: m, |
| node, |
| index: sourceIndex, |
| result: opts.result, |
| ruleName: opts.checkedRuleName |
| }); |
| } |
| }); |
| } |
| }; |