Add ignore: ["inside-block"] and splitList to selector-disallowed-list

lib/rules/selector-disallowed-list/README.md

@@ -66,3 +66,58 @@ a
 ```css
 a[href] {}
 ```
+
+## Optional secondary options
+
+### `iterateThroughSelectorList: true | false` (default: `false`)
+
+This option will apply your configuration to each individual selector in a selector list where each selector is seperated by a comma separated value. ','
+
+For example, with 'true'.
+
+Given the string:
+
+```json
+.foo
+```
+
+The following patterns are considered problems:
+
+<!-- prettier-ignore -->
+```css
+.bar, .foo { }
+```
+
+The following patterns are _not_ considered problems:
+
+<!-- prettier-ignore -->
+```css
+.bar .foo { }
+
+###  `ignore: ["inside-block"]`
+
+Excludes any selectors that are inside a block. Use this if you only want to target selectors at the root level.
+
+Given the string:
+
+```json
+.foo
+```
+
+The following patterns are considered problems:
+
+<!-- prettier-ignore -->
+```css
+.foo { }
+```
+
+The following patterns are _not_ considered problems:
+
+<!-- prettier-ignore -->
+```css
+.bar {
+    .foo {
+
+    }
+}
+```

lib/rules/selector-disallowed-list/__tests__/index.js

@@ -66,6 +66,66 @@ testRule({
 	],
 });
 
+testRule({
+	ruleName,
+	config: [
+		/^\.(foo)[,\s]?(?!\w).*$/,
+		{ ignore: ['inside-block'], iterateThroughSelectorList: true },
+	],
+	accept: [
+		{
+			code: 'a.foo{}',
+		},
+		{
+			code: 'a\n>\n.foo {}',
+		},
+		{
+			code: '.bar > a > .foo {}',
+		},
+		{
+			code: '.bar { .foo {} }',
+		},
+		{
+			code: '.fooo {}',
+		},
+	],
+
+	reject: [
+		{
+			code: '.foo {}',
+			message: messages.rejected('.foo'),
+			line: 1,
+			column: 1,
+			endLine: 1,
+			endColumn: 5,
+		},
+		{
+			code: '.foo > .bar {}',
+			message: messages.rejected('.foo > .bar'),
+			line: 1,
+			column: 1,
+			endLine: 1,
+			endColumn: 12,
+		},
+		{
+			code: '.foo, .bar {}',
+			message: messages.rejected('.foo'),
+			line: 1,
+			column: 1,
+			endLine: 1,
+			endColumn: 5,
+		},
+		{
+			code: '.bar, .foo {}',
+			message: messages.rejected('.foo'),
+			line: 1,
+			column: 7,
+			endColumn: 11,
+			endLine: 1,
+		},
+	],
+});
+
 testRule({
 	ruleName,
 	config: /\.foo[^>]*>.*\.bar/,

lib/rules/selector-disallowed-list/index.js

@@ -3,9 +3,10 @@
 const isStandardSyntaxRule = require('../../utils/isStandardSyntaxRule');
 const matchesStringOrRegExp = require('../../utils/matchesStringOrRegExp');
 const report = require('../../utils/report');
+const optionsMatches = require('../../utils/optionsMatches');
 const ruleMessages = require('../../utils/ruleMessages');
 const validateOptions = require('../../utils/validateOptions');
-const { isRegExp, isString } = require('../../utils/validateTypes');
+const { isRegExp, isString, isBoolean } = require('../../utils/validateTypes');
 
 const ruleName = 'selector-disallowed-list';
 
@@ -17,13 +18,25 @@ const meta = {
 	url: 'https://stylelint.io/user-guide/rules/list/selector-disallowed-list',
 };
 
-/** @type {import('stylelint').Rule<string | RegExp | Array<string | RegExp>>} */
-const rule = (primary) => {
+/** @type {import('stylelint').Rule<string | RegExp | Array<string | RegExp>, { iterateThroughSelectorList: boolean, ignore: string[] }>} */
+const rule = (primary, secondaryOptions) => {
 	return (root, result) => {
-		const validOptions = validateOptions(result, ruleName, {
-			actual: primary,
-			possible: [isString, isRegExp],
-		});
+		const validOptions = validateOptions(
+			result,
+			ruleName,
+			{
+				actual: primary,
+				possible: [isString, isRegExp],
+			},
+			{
+				actual: secondaryOptions,
+				possible: {
+					ignore: ['inside-block'],
+					iterateThroughSelectorList: [isBoolean],
+				},
+				optional: true,
+			},
+		);
 
 		if (!validOptions) {
 			return;
@@ -34,21 +47,45 @@ const rule = (primary) => {
 				return;
 			}
 
-			const { selector, raws } = ruleNode;
+			if (optionsMatches(secondaryOptions, 'ignore', 'inside-block')) {
+				const { parent } = ruleNode;
+				const isInsideBlock = parent && parent.type !== 'root';
 
-			if (!matchesStringOrRegExp(selector, primary)) {
-				return;
+				if (isInsideBlock) {
+					return;
+				}
 			}
 
-			const word = (raws.selector && raws.selector.raw) || selector;
+			const iterateThroughSelectorList =
+				secondaryOptions && secondaryOptions.iterateThroughSelectorList;
+
+			if (iterateThroughSelectorList) {
+				ruleNode.selectors.forEach((selector) => {
+					if (matchesStringOrRegExp(selector, primary)) {
+						report({
+							result,
+							ruleName,
+							message: messages.rejected(selector),
+							node: ruleNode,
+							word: selector,
+						});
+					}
+				});
+			} else {
+				const { selector, raws } = ruleNode;
 
-			report({
-				result,
-				ruleName,
-				message: messages.rejected(selector),
-				node: ruleNode,
-				word,
-			});
+				if (matchesStringOrRegExp(selector, primary)) {
+					const word = (raws.selector && raws.selector.raw) || selector;
+
+					report({
+						result,
+						ruleName,
+						message: messages.rejected(selector),
+						node: ruleNode,
+						word,
+					});
+				}
+			}
 		});
 	};
 };