Add "comment-pattern" rule

docs/user-guide/rules/list.md

@@ -230,6 +230,7 @@ Grouped first by the following categories and then by the [_thing_](http://apps.
 
 - [`comment-word-blacklist`](../../../lib/rules/comment-word-blacklist/README.md): Specify a list of disallowed words within comments. **(deprecated)**
 - [`comment-word-disallowed-list`](../../../lib/rules/comment-word-disallowed-list/README.md): Specify a list of disallowed words within comments.
+- [`comment-pattern`](../../../lib/rules/comment-pattern/README.md): Specify a pattern for comments.
 
 ### General / Sheet
 

lib/rules/comment-pattern/README.md

@@ -0,0 +1,39 @@
+# custom-property-pattern
+
+Specify a pattern for comments.
+
+<!-- prettier-ignore -->
+```css
+                  /*comment*/
+                 /* ↑ */ a { --foo-: 1px; }
+/**                 ↑
+ * The pattern of this */
+```
+
+## Options
+
+`regex`
+
+The pattern to match the comments with.
+
+Given the regex:
+
+```js
+/foo .+/
+```
+
+The following patterns are considered violations:
+
+<!-- prettier-ignore -->
+```css
+/*not starting with foo*/
+a { color: red; }
+```
+
+The following patterns are _not_ considered violations:
+
+<!-- prettier-ignore -->
+```css
+/*foo at the beginning*/
+a { color: red; }
+```

lib/rules/comment-pattern/__tests__/index.js

@@ -0,0 +1,84 @@
+'use strict';
+
+const { messages, ruleName } = require('..');
+
+testRule({
+	ruleName,
+	config: [/foo-.+/],
+
+	accept: [
+		{
+			code: '/* foo-valid yay */',
+		},
+		{
+			code: `/* foo--
+			multi-line
+			\n
+			\r
+			\r\n
+			\n\r
+			\t
+			 */`,
+		},
+		{
+			code: '.without-comment {}',
+		},
+	],
+
+	reject: [
+		{
+			code: '/* not foo- */',
+			message: messages.expected,
+		},
+		{
+			code: '/**/',
+			message: messages.expected,
+		},
+	],
+});
+
+testRule({
+	ruleName,
+	config: [true],
+
+	accept: [
+		{
+			code: '/* some comment */',
+		},
+		{
+			code: '/**/',
+		},
+		{
+			code: '.without-comment {}',
+		},
+	]
+});
+
+testRule({
+	ruleName,
+	config: [/foo-.+/],
+	syntax: 'scss',
+
+	accept: [
+		{
+			code: 'a {} // foo-ok',
+			description: 'ignored inline scss comments',
+		},
+		{
+			code: '// foo-ok',
+			description: 'ignored inline scss comments',
+		},
+		{
+			code: '.without-comment { }',
+			description: 'ignores scss without comments',
+		},
+	],
+
+	reject: [
+		{
+			code: 'a {} // not-foo',
+			description: 'checks inline scss comments',
+			message: messages.expected,
+		},
+	]
+});

lib/rules/comment-pattern/index.js

@@ -0,0 +1,47 @@
+// @ts-nocheck
+
+'use strict';
+
+const _ = require('lodash');
+const report = require('../../utils/report');
+const ruleMessages = require('../../utils/ruleMessages');
+const validateOptions = require('../../utils/validateOptions');
+
+const ruleName = 'comment-pattern';
+
+const messages = ruleMessages(ruleName, {
+	expected: 'Expected comment to match specified pattern',
+});
+
+function rule(pattern) {
+	return (root, result) => {
+		const validOptions = validateOptions(result, ruleName, {
+			actual: pattern,
+			possible: [_.isRegExp],
+		});
+
+		if (!validOptions) {
+			return;
+		}
+
+		root.walkComments((comment) => {
+			const text = comment.text;
+
+
+			if (pattern.test(text)) {
+				return;
+			}
+
+			report({
+				message: messages.expected,
+				node: comment,
+				result,
+				ruleName,
+			});
+		});
+	};
+}
+
+rule.ruleName = ruleName;
+rule.messages = messages;
+module.exports = rule;

lib/rules/index.js

@@ -61,6 +61,7 @@ const rules = {
 	'color-no-invalid-hex': importLazy(() => require('./color-no-invalid-hex'))(),
 	'comment-empty-line-before': importLazy(() => require('./comment-empty-line-before'))(),
 	'comment-no-empty': importLazy(() => require('./comment-no-empty'))(),
+	'comment-pattern': importLazy(() => require('./comment-pattern'))(),
 	'comment-whitespace-inside': importLazy(() => require('./comment-whitespace-inside'))(),
 	'comment-word-blacklist': importLazy(() => require('./comment-word-blacklist'))(),
 	'comment-word-disallowed-list': importLazy(() => require('./comment-word-disallowed-list'))(),