Merge remote-tracking branch 'upstream/master' into add_support_for_has

Author: elacuesta

cssselect/parser.py

@@ -280,6 +280,31 @@ def specificity(self):
         return a1 + a2, b1 + b2, c1 + c2
 
 
+class Matching(object):
+    """
+    Represents selector:is(selector_list)
+    """
+    def __init__(self, selector, selector_list):
+        self.selector = selector
+        self.selector_list = selector_list
+
+    def __repr__(self):
+        return '%s[%r:is(%s)]' % (
+            self.__class__.__name__, self.selector, ", ".join(
+                map(repr, self.selector_list)))
+
+    def canonical(self):
+        selector_arguments = []
+        for s in self.selector_list:
+            selarg = s.canonical()
+            selector_arguments.append(selarg.lstrip('*'))
+        return '%s:is(%s)' % (self.selector.canonical(),
+                              ", ".join(map(str, selector_arguments)))
+
+    def specificity(self):
+        return max([x.specificity() for x in self.selector_list])
+
+
 class Attrib(object):
     """
     Represents selector[namespace|attrib operator value]
@@ -462,6 +487,7 @@ def parse_selector_group(stream):
         else:
             break
 
+
 def parse_selector(stream):
     result, pseudo_element = parse_simple_selector(stream)
     while 1:
@@ -571,6 +597,9 @@ def parse_simple_selector(stream, inside_negation=False):
             elif ident.lower() == "has":
                 arguments = parse_relative_selector(stream)
                 result = Relation(result, arguments)
+            elif ident.lower() in ('matches', 'is'):
+                selectors = parse_simple_selector_arguments(stream)
+                result = Matching(result, selectors)
             else:
                 result = Function(result, ident, parse_arguments(stream))
         else:
@@ -616,6 +645,29 @@ def parse_relative_selector(stream):
                 "Expected an argument, got %s" % (next,))
 
 
+def parse_simple_selector_arguments(stream):
+    arguments = []
+    while 1:
+        result, pseudo_element = parse_simple_selector(stream, True)
+        if pseudo_element:
+            raise SelectorSyntaxError(
+                'Got pseudo-element ::%s inside function'
+                % (pseudo_element, ))
+        stream.skip_whitespace()
+        next = stream.next()
+        if next in (('EOF', None), ('DELIM', ',')):
+            stream.next()
+            stream.skip_whitespace()
+            arguments.append(result)
+        elif next == ('DELIM', ')'):
+            arguments.append(result)
+            break
+        else:
+            raise SelectorSyntaxError(
+                "Expected an argument, got %s" % (next,))
+    return arguments
+
+
 def parse_attrib(selector, stream):
     stream.skip_whitespace()
     attrib = stream.next_ident_or_star()

cssselect/xpath.py

@@ -55,9 +55,9 @@ def __str__(self):
     def __repr__(self):
         return '%s[%s]' % (self.__class__.__name__, self)
 
-    def add_condition(self, condition):
+    def add_condition(self, condition, conjuction='and'):
         if self.condition:
-            self.condition = '(%s) and (%s)' % (self.condition, condition)
+            self.condition = '(%s) %s (%s)' % (self.condition, conjuction, condition)
         else:
             self.condition = condition
         return self
@@ -289,6 +289,15 @@ def xpath_relation(self, relation):
         )
         return method(xpath, right)
 
+    def xpath_matching(self, matching):
+        xpath = self.xpath(matching.selector)
+        exprs = [self.xpath(selector) for selector in matching.selector_list]
+        for e in exprs:
+            e.add_name_test()
+            if e.condition:
+                xpath.add_condition(e.condition, 'or')
+        return xpath
+
     def xpath_function(self, function):
         """Translate a functional pseudo-class."""
         method = 'xpath_%s_function' % function.name.replace('-', '_')

tests/test_cssselect.py

@@ -145,6 +145,10 @@ def parse_many(first, *others):
             'Hash[Element[div]#foobar]']
         assert parse_many('div:not(div.foo)') == [
             'Negation[Element[div]:not(Class[Element[div].foo])]']
+        assert parse_many('div:is(.foo, #bar)') == [
+            'Matching[Element[div]:is(Class[Element[*].foo], Hash[Element[*]#bar])]']
+        assert parse_many(':is(:hover, :visited)') == [
+            'Matching[Element[*]:is(Pseudo[Element[*]:hover], Pseudo[Element[*]:visited])]']
         assert parse_many('td ~ th') == [
             'CombinedSelector[Element[td] ~ Element[th]]']
         assert parse_many(':scope > foo') == [
@@ -270,6 +274,8 @@ def specificity(css):
         assert specificity(':has(foo)') == (0, 0, 1)
         assert specificity(':has(> foo)') == (0, 0, 1)
 
+        assert specificity(':is(.foo, #bar)') == (1, 0, 0)
+        assert specificity(':is(:hover, :visited)') == (0, 1, 0)
 
         assert specificity('foo:empty') == (0, 1, 1)
         assert specificity('foo:before') == (0, 0, 2)
@@ -311,6 +317,8 @@ def css2css(css, res=None):
         # css2css(':has(*[foo])', ':has([foo])')
         # css2css(':has(:empty)')
         # css2css(':has(#foo)')
+        css2css(':is(#bar, .foo)')
+        css2css(':is(:focused, :visited)')
         css2css('foo:empty')
         css2css('foo::before')
         css2css('foo:empty::before')
@@ -384,6 +392,10 @@ def get_error(css):
             "Got pseudo-element ::before inside :not() at 12")
         assert get_error(':not(:not(a))') == (
             "Got nested :not()")
+        assert get_error(':is(:before)') == (
+            "Got pseudo-element ::before inside function")
+        assert get_error(':is(a b)') == (
+            "Expected an argument, got <IDENT 'b' at 6>")
         assert get_error(':scope > div :scope header') == (
             'Got immediate child pseudo-element ":scope" not at the start of a selector'
         )
@@ -502,7 +514,7 @@ def xpath(css):
         assert xpath('e:not(:nth-child(odd))') == (
             "e[not(count(preceding-sibling::*) mod 2 = 0)]")
         assert xpath('e:nOT(*)') == (
-            "e[0]")  # never matches        
+            "e[0]")  # never matches
         assert xpath('e:has(> f)') == 'e[./f]'
         assert xpath('e:has(f)') == 'e/descendant-or-self::f/ancestor-or-self::e'
         assert xpath('e:has(~ f)') == 'e/following-sibling::f/preceding-sibling::e'
@@ -881,6 +893,12 @@ def pcss(main, *selectors, **kwargs):
         # assert pcss('link:has(*)') == []
         # assert pcss('link:has([href])') == ['link-href']
         # assert pcss('ol:has(div)') == ['first-ol']
+        assert pcss(':is(#first-li, #second-li)') == [
+            'first-li', 'second-li']
+        assert pcss('a:is(#name-anchor, #tag-anchor)') == [
+            'name-anchor', 'tag-anchor']
+        assert pcss(':is(.c)') == [
+            'first-ol', 'third-li', 'fourth-li']
         assert pcss('ol.a.b.c > li.c:nth-child(3)') == ['third-li']
 
         # Invalid characters in XPath element names, should not crash