Add ignore: ["next-sibling"] to selector-max-type

lib/rules/selector-max-type/README.md

@@ -69,7 +69,7 @@ The following patterns are *not* considered violations:
 
 ## Optional secondary options
 
-### `ignore: ["child", "compounded", "descendant"]`
+### `ignore: ["child", "compounded", "descendant", "next-sibling"]`
 
 #### `"child"`
 
@@ -119,6 +119,24 @@ The following patterns are *not* considered violations:
 #bar div span a {}
 ```
 
+#### "next-sibling"
+
+Discount next-sibling type selectors.
+
+For example, with `2`:
+
+The following patterns are *not* considered violations:
+
+```css
+div a + span {}
+```
+
+```css
+#bar + div + span + a + span {}
+```
+
+
+
 ### `ignoreTypes: ["/regex/", "string"]`
 
 Given:

lib/rules/selector-max-type/__tests__/index.js

@@ -549,3 +549,82 @@ testRule(rule, {
     }
   ]
 });
+
+testRule(rule, {
+  ruleName,
+  config: [0, { ignore: ["next-sibling"] }],
+  skipBasicChecks: true,
+  syntax: "scss",
+
+  accept: [
+    {
+      code: ".foo + a {}"
+    },
+    {
+      code: ".foo, .bar + a {}"
+    },
+    {
+      code: ".foo + a + b {}"
+    },
+    {
+      code: ".foo { .bar + a {} }"
+    },
+    {
+      code: ".foo, .bar + baz {}"
+    },
+    {
+      code:
+        ".foo + bar + foo + baz + bar, .foo + baz, .baz + .foo { .baz + foo + bar + foo { .foo + foo {} } }, .lol + .lol {}"
+    }
+  ],
+
+  reject: [
+    {
+      code: "foo {}",
+      message: messages.expected("foo", 0),
+      line: 1,
+      column: 1
+    },
+    {
+      code: "bar baz {}",
+      message: messages.expected("bar baz", 0),
+      line: 1,
+      column: 1
+    },
+    {
+      code: "bar + baz {}",
+      message: messages.expected("bar + baz", 0),
+      line: 1,
+      column: 1
+    },
+    {
+      code: "foo + bar + baz {}",
+      message: messages.expected("foo + bar + baz", 0),
+      line: 1,
+      column: 1
+    },
+    {
+      code: "foo, .bar + baz {}",
+      message: messages.expected("foo", 0),
+      line: 1,
+      column: 1
+    },
+    {
+      code: ".foo + bar, baz {}",
+      message: messages.expected("baz", 0),
+      line: 1,
+      column: 13
+    },
+    {
+      code: ".foo + .bar { baz {} }",
+      message: messages.expected(".foo + .bar baz", 0),
+      line: 1,
+      column: 15
+    },
+    {
+      code: ".foo + .bar { .baz + .foo { foo + bar {} } }",
+      message: messages.expected(".foo + .bar .baz + .foo foo + bar", 0),
+      line: 1
+    }
+  ]
+});

lib/rules/selector-max-type/index.js

@@ -35,7 +35,7 @@ function rule(max, options) {
       {
         actual: options,
         possible: {
-          ignore: ["descendant", "child", "compounded"],
+          ignore: ["descendant", "child", "compounded", "next-sibling"],
           ignoreTypes: [_.isString]
         },
         optional: true
@@ -49,6 +49,7 @@ function rule(max, options) {
     const ignoreDescendant = optionsMatches(options, "ignore", "descendant");
     const ignoreChild = optionsMatches(options, "ignore", "child");
     const ignoreCompounded = optionsMatches(options, "ignore", "compounded");
+    const ignoreNextSibling = optionsMatches(options, "ignore", "next-sibling");
 
     function checkSelector(selectorNode, ruleNode) {
       const count = selectorNode.reduce((total, childNode) => {
@@ -73,7 +74,11 @@ function rule(max, options) {
           return total;
         }
 
-        return (total += childNode.type === "tag" ? 1 : 0);
+        if (ignoreNextSibling && hasNextSiblingCombinator(childNode)) {
+          return total;
+        }
+
+        return total + (childNode.type === "tag");
       }, 0);
 
       if (
@@ -148,11 +153,11 @@ function hasCompoundSelector(node) {
     return true;
   }
 
-  if (node.next() && !isCombinator(node.next())) {
-    return true;
-  }
+  return node.next() && !isCombinator(node.next());
+}
 
-  return false;
+function hasNextSiblingCombinator(node) {
+  return node.prev() && isNextSiblingCombinator(node.prev());
 }
 
 function isCombinator(node) {
@@ -170,7 +175,11 @@ function isDescendantCombinator(node) {
 function isChildCombinator(node) {
   if (!node) return false;
 
-  return isCombinator(node) && node.value.includes(">");
+  return isCombinator(node) && node.value === ">";
+}
+
+function isNextSiblingCombinator(node) {
+  return isCombinator(node) && node.value === "+";
 }
 
 rule.ruleName = ruleName;