support parsing complex selector in :not()

Author: annbgn

cssselect/parser.py

@@ -238,12 +238,22 @@ class Negation(object):
     Represents selector:not(subselector)
     """
 
-    def __init__(self, selector, subselector):
+    def __init__(self, selector, subselector, combinator=None, subselector2=None):
         self.selector = selector
         self.subselector = subselector
+        self.combinator = combinator
+        self.subselector2 = subselector2
 
     def __repr__(self):
-        return "%s[%r:not(%r)]" % (self.__class__.__name__, self.selector, self.subselector)
+        if self.combinator is None and self.subselector2 is None:
+            return "%s[%r:not(%r)]" % (self.__class__.__name__, self.selector, self.subselector)
+        return "%s[%r:not(%r %s %r)]" % (
+            self.__class__.__name__,
+            self.selector,
+            self.subselector,
+            self.combinator.value,
+            self.subselector2.parsed_tree,
+        )
 
     def canonical(self):
         subsel = self.subselector.canonical()
@@ -614,9 +624,11 @@ def parse_simple_selector(stream, inside_negation=False):
                         "Got pseudo-element ::%s inside :not() at %s"
                         % (argument_pseudo_element, next.pos)
                     )
+                combinator = arguments = None
                 if next != ("DELIM", ")"):
-                    raise SelectorSyntaxError("Expected ')', got %s" % (next,))
-                result = Negation(result, argument)
+                    stream.skip_whitespace()
+                    combinator, arguments = parse_relative_selector(stream)
+                result = Negation(result, argument, combinator, arguments)
             elif ident.lower() == "has":
                 combinator, arguments = parse_relative_selector(stream)
                 result = Relation(result, combinator, arguments)

cssselect/xpath.py

@@ -271,7 +271,14 @@ def xpath_negation(self, negation):
         xpath = self.xpath(negation.selector)
         sub_xpath = self.xpath(negation.subselector)
         sub_xpath.add_name_test()
-        if sub_xpath.condition:
+        if (
+            sub_xpath.condition
+            and negation.combinator is not None
+            and negation.subselector2 is not None
+        ):
+            sub2_xpath = self.xpath(negation.subselector2.parsed_tree)
+            return sub2_xpath.join("[..", sub_xpath, closing_combiner="]")
+        elif sub_xpath.condition:
             return xpath.add_condition("not(%s)" % sub_xpath.condition)
         else:
             return xpath.add_condition("0")

tests/test_cssselect.py

@@ -145,6 +145,7 @@ def parse_many(first, *others):
         assert parse_many("a:lang(fr)") == ["Function[Element[a]:lang(['fr'])]"]
         assert parse_many('div:contains("foo")') == ["Function[Element[div]:contains(['foo'])]"]
         assert parse_many("div#foobar") == ["Hash[Element[div]#foobar]"]
+        assert parse_many(":not(a > b)") == ["Negation[Element[*]:not(Element[a] > Element[b])]"]
         assert parse_many("div:not(div.foo)") == [
             "Negation[Element[div]:not(Class[Element[div].foo])]"
         ]
@@ -391,10 +392,8 @@ def get_error(css):
         assert get_error("> div p") == ("Expected selector, got <DELIM '>' at 0>")
 
         # Unsupported :has() with several arguments
-        assert get_error(':has(a, b)') == (
-            "Expected an argument, got <DELIM ',' at 6>")
-        assert get_error(':has()') == (
-            "Expected selector, got <EOF at 0>")
+        assert get_error(":has(a, b)") == ("Expected an argument, got <DELIM ',' at 6>")
+        assert get_error(":has()") == ("Expected selector, got <EOF at 0>")
 
     def test_translation(self):
         def xpath(css):
@@ -470,12 +469,14 @@ def xpath(css):
         assert xpath("e:EmPTY") == ("e[not(*) and not(string-length())]")
         assert xpath("e:root") == ("e[not(parent::*)]")
         assert xpath("e:hover") == ("e[0]")  # never matches
+        assert (
+            xpath("*:not(f > e)") == "e[..[not(name() = 'f')]]"
+        )  # select e whose parent is not f
         assert xpath("e:has(> f)") == "e[./f]"
         assert xpath("e:has(f)") == "e[descendant::f]"
         assert xpath("e:has(~ f)") == "e[following-sibling::f]"
         assert (
-            xpath("e:has(+ f)")
-            == "e[following-sibling::*[(name() = 'f') and (position() = 1)]]"
+            xpath("e:has(+ f)") == "e[following-sibling::*[(name() = 'f') and (position() = 1)]]"
         )
         assert xpath('e:contains("foo")') == ("e[contains(., 'foo')]")
         assert xpath("e:ConTains(foo)") == ("e[contains(., 'foo')]")