brewdoc-linux-x64-glibc 0.0.0-stage → 0.3.2

package/binary/_internal/selectolax/lexbor/node_remove.pxi

@@ -0,0 +1,29 @@
+
+cdef lxb_dom_node_t * node_remove_deep(lxb_dom_node_t* root):
+    cdef lxb_dom_node_t *tmp
+    cdef lxb_dom_node_t *node = root
+
+    while node != NULL:
+        if node.first_child != NULL:
+            node = node.first_child
+        else:
+            while node != root and node.next == NULL:
+                tmp = node.parent
+                lxb_dom_node_remove(node)
+                node = tmp
+
+            if node == root:
+                lxb_dom_node_remove(node)
+                break
+
+            tmp = node.next
+            lxb_dom_node_remove(node)
+            node = tmp
+
+    return NULL
+
+cdef bint node_is_removed(lxb_dom_node_t* node):
+    if node.parent == NULL and node.next == NULL \
+       and node.prev == NULL:
+        return 1
+    return 0

package/binary/_internal/selectolax/lexbor/selection.pxi

@@ -0,0 +1,251 @@
+cimport cython
+from cpython.exc cimport PyErr_SetObject
+from cpython.list cimport PyList_GET_SIZE
+
+
+@cython.final
+cdef class LexborCSSSelector:
+
+    def __init__(self):
+        self._create_css_parser()
+        self.results = []
+        self.current_node = None
+
+    cdef int _create_css_parser(self) except -1:
+        cdef lxb_status_t status
+
+        self.parser = lxb_css_parser_create()
+        if self.parser == NULL:
+            PyErr_SetObject(SelectolaxError, "Can't create CSS parser.")
+            return -1
+
+        status = lxb_css_parser_init(self.parser, NULL)
+        if status != LXB_STATUS_OK:
+            lxb_css_parser_destroy(self.parser, True)
+            self.parser = NULL
+            PyErr_SetObject(SelectolaxError, "Can't initialize CSS parser.")
+            return -1
+
+        self.css_selectors = lxb_css_selectors_create()
+        if self.css_selectors == NULL:
+            lxb_css_parser_destroy(self.parser, True)
+            self.parser = NULL
+            PyErr_SetObject(SelectolaxError, "Can't create CSS selector.")
+            return -1
+
+        status = lxb_css_selectors_init(self.css_selectors)
+        if status != LXB_STATUS_OK:
+            lxb_css_selectors_destroy(self.css_selectors, True)
+            self.css_selectors = NULL
+            lxb_css_parser_destroy(self.parser, True)
+            self.parser = NULL
+            PyErr_SetObject(SelectolaxError, "Can't initialize CSS selector.")
+            return -1
+
+        lxb_css_parser_selectors_set(self.parser, self.css_selectors)
+
+        self.selectors = lxb_selectors_create()
+        if self.selectors == NULL:
+            lxb_css_selectors_destroy(self.css_selectors, True)
+            self.css_selectors = NULL
+            lxb_css_parser_destroy(self.parser, True)
+            self.parser = NULL
+            PyErr_SetObject(SelectolaxError, "Can't create selector.")
+            return -1
+
+        status = lxb_selectors_init(self.selectors)
+        if status != LXB_STATUS_OK:
+            lxb_selectors_destroy(self.selectors, True)
+            self.selectors = NULL
+            lxb_css_selectors_destroy(self.css_selectors, True)
+            self.css_selectors = NULL
+            lxb_css_parser_destroy(self.parser, True)
+            self.parser = NULL
+            PyErr_SetObject(SelectolaxError, "Can't initialize selector.")
+            return -1
+
+        lxb_selectors_opt_set(self.selectors, LXB_SELECTORS_OPT_MATCH_ROOT)
+        return 0
+
+    cpdef list find(self, str query, LexborNode node):
+        return self._find(query, node, 0)
+
+    cpdef list find_first(self, str query, LexborNode node):
+        return self._find(query, node, 1)
+
+    cpdef list _find(self, str query, LexborNode node, bint only_first):
+        cdef lxb_css_selector_list_t* selectors
+        cdef lxb_char_t* c_selector
+        cdef lxb_css_selector_list_t * selectors_list
+
+        if not isinstance(query, str):
+            raise TypeError("Query must be a string.")
+
+        bytes_query = query.encode(_ENCODING)
+        selectors_list = lxb_css_selectors_parse(self.parser, <lxb_char_t *> bytes_query, <size_t>len(bytes_query))
+
+        if selectors_list == NULL:
+            raise SelectolaxError("Can't parse CSS selector.")
+
+        self.current_node = node
+        self.results = []
+        if only_first:
+            status = lxb_selectors_find(self.selectors, node.node, selectors_list,
+                                        <lxb_selectors_cb_f>css_finder_callback_first, <void*>self)
+        else:
+            status = lxb_selectors_find(self.selectors, node.node, selectors_list,
+                                        <lxb_selectors_cb_f>css_finder_callback, <void*>self)
+        results = list(self.results)
+        self.results = []
+        self.current_node = None
+        lxb_css_selector_list_destroy_memory(selectors_list)
+        self.parser.memory = NULL
+        return results
+
+    cpdef int any_matches(self, str query, LexborNode node) except -1:
+        cdef lxb_css_selector_list_t * selectors
+        cdef lxb_char_t * c_selector
+        cdef lxb_css_selector_list_t * selectors_list
+        cdef int result
+
+        if not isinstance(query, str):
+            raise TypeError("Query must be a string.")
+
+        bytes_query = query.encode(_ENCODING)
+        selectors_list = lxb_css_selectors_parse(self.parser, <lxb_char_t *> bytes_query, <size_t> len(bytes_query))
+
+        if selectors_list == NULL:
+            PyErr_SetObject(SelectolaxError, "Can't parse CSS selector.")
+            return -1
+
+        self.results = []
+        status = lxb_selectors_find(self.selectors, node.node, selectors_list,
+                                    <lxb_selectors_cb_f> css_matcher_callback, <void *> self)
+        if status != LXB_STATUS_OK:
+            lxb_css_selector_list_destroy_memory(selectors_list)
+            self.parser.memory = NULL
+            PyErr_SetObject(SelectolaxError, "Can't parse CSS selector.")
+            return -1
+
+        result = PyList_GET_SIZE(self.results) > 0
+        self.results = []
+        lxb_css_selector_list_destroy_memory(selectors_list)
+        self.parser.memory = NULL
+        return result
+
+    def __dealloc__(self):
+        if self.selectors != NULL:
+            lxb_selectors_destroy(self.selectors, True)
+        if self.parser != NULL:
+            lxb_css_parser_destroy(self.parser, True)
+        if self.css_selectors != NULL:
+            lxb_css_selectors_destroy(self.css_selectors, True)
+
+
+cdef class LexborSelector:
+    """An advanced CSS selector that supports additional operations.
+
+    Think of it as a toolkit that mimics some of the features of XPath.
+
+    Please note, this is an experimental feature that can change in the future.
+    """
+    cdef LexborNode node
+    cdef list nodes
+
+    def __init__(self, LexborNode node, query):
+        self.node = node
+        self.nodes = self.node.parser.selector.find(query, self.node) if query else [node, ]
+
+    cpdef css(self, str query):
+        """Evaluate CSS selector against current scope."""
+        raise NotImplementedError("This features is not supported by the lexbor backend. Please use Modest backend.")
+
+    @property
+    def matches(self) -> list:
+        """Returns all possible matches"""
+        return self.nodes
+
+    @property
+    def any_matches(self) -> bool:
+        """Returns True if there are any matches"""
+        return bool(self.nodes)
+
+    def text_contains(self, str text, bool deep=True, str separator='', bool strip=False) -> LexborSelector:
+        """Filter all current matches given text."""
+        cdef list nodes = []
+        for node in self.nodes:
+            node_text = node.text(deep=deep, separator=separator, strip=strip)
+            if node_text and text in node_text:
+                nodes.append(node)
+        self.nodes = nodes
+        return self
+
+    def any_text_contains(self, str text, bool deep=True, str separator='', bool strip=False) -> bool:
+        """Returns True if any node in the current search scope contains specified text"""
+        cdef LexborNode node
+        for node in self.nodes:
+            node_text = node.text(deep=deep, separator=separator, strip=strip)
+            if node_text and text in node_text:
+                return True
+        return False
+
+    def attribute_longer_than(self, str attribute, int length, str start  = None) -> LexborSelector:
+        """Filter all current matches by attribute length.
+
+        Similar to `string-length` in XPath.
+        """
+        cdef list nodes = []
+        for node in self.nodes:
+            attr = node.attributes.get(attribute)
+            if not attr:
+                continue
+            if attr and start and start in attr:
+                attr = attr[attr.find(start) + len(start):]
+            if len(attr) > length:
+                nodes.append(node)
+        self.nodes = nodes
+        return self
+
+    def any_attribute_longer_than(self, str attribute, int length, str start  = None) -> bool:
+        """Returns True any href attribute longer than a specified length.
+
+        Similar to `string-length` in XPath.
+        """
+        cdef LexborNode node
+        for node in self.nodes:
+            attr = node.attributes.get(attribute)
+            if attr is None:
+                continue
+            if start and start in attr:
+                attr = attr[attr.find(start) + len(start):]
+            if len(attr) > length:
+                return True
+        return False
+
+    def __bool__(self):
+        return bool(self.nodes)
+
+
+cdef lxb_status_t css_finder_callback(lxb_dom_node_t *node, lxb_css_selector_specificity_t *spec, void *ctx):
+    cdef LexborNode lxb_node
+    cdef LexborCSSSelector cls
+    cls = <LexborCSSSelector> ctx
+    lxb_node = LexborNode.new(<lxb_dom_node_t *> node, cls.current_node.parser)
+    cls.results.append(lxb_node)
+    return LXB_STATUS_OK
+
+cdef lxb_status_t css_finder_callback_first(lxb_dom_node_t *node, lxb_css_selector_specificity_t *spec, void *ctx):
+    cdef LexborNode lxb_node
+    cdef LexborCSSSelector cls
+    cls = <LexborCSSSelector> ctx
+    lxb_node = LexborNode.new(<lxb_dom_node_t *> node, cls.current_node.parser)
+    cls.results.append(lxb_node)
+    return LXB_STATUS_STOP
+
+
+cdef lxb_status_t css_matcher_callback(lxb_dom_node_t *node, lxb_css_selector_specificity_t *spec, void *ctx):
+    cdef LexborNode lxb_node
+    cdef LexborCSSSelector cls
+    cls = <LexborCSSSelector> ctx
+    cls.results.append(True)
+    return LXB_STATUS_STOP

package/binary/_internal/selectolax/lexbor/util.pxi

@@ -0,0 +1,114 @@
+include "../utils.pxi"
+
+import re
+
+
+def create_tag(tag: str):
+    """
+    Given an HTML tag name, e.g. `"div"`, create a single empty node for that tag,
+    e.g. `"<div></div>"`.
+
+    Use `LexborHTMLParser().create_node(..)` if you need to create a node tied to a specific parser instance.
+    """
+    return LexborHTMLParser(f"<{tag}></{tag}>", is_fragment=True).root
+
+
+def parse_fragment(html: str):
+    """
+    Given HTML, parse it into a list of Nodes, such that the nodes
+    correspond to the given HTML.
+
+    For contrast, HTMLParser adds `<html>`, `<head>`, and `<body>` tags
+    if they are missing. This function does not add these tags.
+    """
+    return do_parse_fragment(html, LexborHTMLParser)
+
+
+def extract_html_comment(text: str) -> str:
+    """Extract the inner content of an HTML comment string.
+
+    Args:
+        text: Raw HTML comment, including the ``<!--`` and ``-->`` markers.
+
+    Returns:
+        The comment body with surrounding whitespace stripped.
+
+    Raises:
+        ValueError: If the input is not a well-formed HTML comment.
+
+    Examples:
+        >>> extract_html_comment("<!-- hello -->")
+        'hello'
+    """
+    if match := re.fullmatch(r"\s*<!--\s*(.*?)\s*-->\s*", text, flags=re.DOTALL):
+        return match.group(1).strip()
+    msg = "Input is not a valid HTML comment"
+    raise ValueError(msg)
+
+
+cdef inline bint is_empty_text_node(lxb_dom_node_t *text_node):
+    """
+    Check whether a node is a text node made up solely of HTML ASCII whitespace.
+
+    Parameters
+    ----------
+    text_node : lxb_dom_node_t *
+        Pointer to the node that should be inspected.
+
+    Returns
+    -------
+    bint
+        ``True`` if ``text_node`` is a text node whose character data contains
+        only space, tab, newline, form feed, or carriage return characters;
+        otherwise ``False``.
+    """
+    if text_node == NULL or text_node.type != LXB_DOM_NODE_TYPE_TEXT:
+        return False
+
+    cdef lxb_dom_character_data_t *text_character_data = <lxb_dom_character_data_t *> text_node
+    cdef lexbor_str_t *text_buffer = &text_character_data.data
+    cdef size_t text_length = text_buffer.length
+    cdef lxb_char_t *text_bytes = text_buffer.data
+
+    return _is_whitespace_only(text_bytes, text_length)
+
+
+cdef inline bint _is_whitespace_only(const lxb_char_t *buffer, size_t buffer_length) nogil:
+    """
+    Determine whether a byte buffer consists only of HTML ASCII whitespace.
+
+    Parameters
+    ----------
+    buffer : const lxb_char_t *
+        Pointer to the buffer to inspect.
+    buffer_length : size_t
+        Number of bytes available in ``buffer``.
+
+    Returns
+    -------
+    bint
+        ``True`` if ``buffer`` is ``NULL``, empty, or contains only space
+        (0x20), tab (0x09), line feed (0x0A), form feed (0x0C), or carriage
+        return (0x0D) bytes; otherwise ``False``.
+
+    Notes
+    -----
+    Mirrors Lexbor's ``lexbor_utils_whitespace`` macro and stays inline to
+    keep the GIL released in hot loops.
+    """
+    cdef const lxb_char_t *cursor = buffer
+    cdef const lxb_char_t *end = buffer + buffer_length
+    cdef lxb_char_t current_char
+
+    if buffer == NULL or buffer_length == 0:
+        return True
+
+    # Inline whitespace check mirroring lexbor_utils_whitespace(chr, !=, &&)
+    while cursor < end:
+        current_char = cursor[0]
+        if (current_char != ' ' and current_char != '\t' and current_char != '\n'
+                and current_char != '\f' and current_char != '\r'):
+            return False
+        cursor += 1
+
+    return True