index.js

'use strict';

const isStandardSyntaxRule = require('../../utils/isStandardSyntaxRule');
const isStandardSyntaxSelector = require('../../utils/isStandardSyntaxSelector');
const parseSelector = require('../../utils/parseSelector');
const punctuationSets = require('../../reference/punctuationSets');
const report = require('../../utils/report');
const ruleMessages = require('../../utils/ruleMessages');
const validateOptions = require('../../utils/validateOptions');

const ruleName = 'selector-descendant-combinator-no-non-space';

const messages = ruleMessages(ruleName, {
	rejected: (nonSpaceCharacter) => `Unexpected "${nonSpaceCharacter}"`,
});

const rule = function(expectation, options, context) {
	return (root, result) => {
		const validOptions = validateOptions(result, ruleName, {
			actual: expectation,
		});

		if (!validOptions) {
			return;
		}

		root.walkRules((rule) => {
			if (!isStandardSyntaxRule(rule)) {
				return;
			}

			let hasFixed = false;
			const selector = rule.raws.selector ? rule.raws.selector.raw : rule.selector;

			if (!isStandardSyntaxSelector(selector)) {
				return;
			}

			const fixedSelector = parseSelector(selector, result, rule, (fullSelector) => {
				fullSelector.walkCombinators((combinatorNode) => {
					if (!isActuallyCombinator(combinatorNode)) {
						return;
					}

					const value = combinatorNode.value;

					if (punctuationSets.nonSpaceCombinators.has(value)) {
						return;
					}

					if (
						value.includes('  ') ||
						value.includes('\t') ||
						value.includes('\n') ||
						value.includes('\r')
					) {
						if (context.fix && /^\s+$/.test(value)) {
							hasFixed = true;
							combinatorNode.value = ' ';

							return;
						}

						report({
							result,
							ruleName,
							message: messages.rejected(value),
							node: rule,
							index: combinatorNode.sourceIndex,
						});
					}
				});
			});

			if (hasFixed) {
				if (!rule.raws.selector) {
					rule.selector = fixedSelector;
				} else {
					rule.raws.selector.raw = fixedSelector;
				}
			}
		});
	};
};

rule.ruleName = ruleName;
rule.messages = messages;
module.exports = rule;

/**
 * Check whether is actually a combinator.
 * @param {Node} combinatorNode The combinator node
 * @returns {boolean} `true` if is actually a combinator.
 */
function isActuallyCombinator(combinatorNode) {
	// `.foo  /*comment*/, .bar`
	//      ^^
	// If include comments, this spaces is a combinator, but it is not combinators.
	if (!/^\s+$/.test(combinatorNode.value)) {
		return true;
	}

	let next = combinatorNode.next();

	while (skipTest(next)) {
		next = next.next();
	}

	if (isNonTarget(next)) {
		return false;
	}

	let prev = combinatorNode.prev();

	while (skipTest(prev)) {
		prev = prev.prev();
	}

	if (isNonTarget(prev)) {
		return false;
	}

	return true;

	function skipTest(node) {
		if (!node) {
			return false;
		}

		if (node.type === 'comment') {
			return true;
		}

		if (node.type === 'combinator' && /^\s+$/.test(node.value)) {
			return true;
		}

		return false;
	}

	function isNonTarget(node) {
		if (!node) {
			return true;
		}

		if (node.type === 'combinator' && !/^\s+$/.test(node.value)) {
			return true;
		}

		return false;
	}
}