gumbo-html 0.2.3 → 0.3.0

package/src/xnode_query.c

@@ -0,0 +1,330 @@
+#include "xnode_query.h"
+
+#include <assert.h>
+#include <ctype.h>
+#include <string.h>
+
+#ifdef _WIN32
+#define strcasecmp(x,y) _stricmp(x,y)
+#define strncasecmp(x,y,z) _strnicmp(x,y,z)
+#else
+#include <strings.h>
+#endif
+
+static int string_ends_with(const char *str, const char *suffix) {
+    if (!str || !suffix) {
+        return 0;
+    } else {
+        size_t lenstr = strlen(str);
+        size_t lensuffix = strlen(suffix);
+        if (lensuffix > lenstr) return 0;
+        return strncmp(str + lenstr - lensuffix, suffix, lensuffix) == 0;
+    }
+}
+
+static int is_html_space(char c) {
+    return isspace((unsigned char)c);
+}
+
+static int string_in_space_list(const char *str, const char *tok) {
+    size_t tok_len;
+
+    if (!str || !tok || *tok == '\0') {
+        return 0;
+    }
+
+    tok_len = strlen(tok);
+    while (*str) {
+        while (*str && is_html_space(*str)) {
+            str++;
+        }
+
+        if (!strncmp(str, tok, tok_len) &&
+                (str[tok_len] == '\0' || is_html_space(str[tok_len]))) {
+            return 1;
+        }
+
+        while (*str && !is_html_space(*str)) {
+            str++;
+        }
+    }
+
+    return 0;
+}
+
+static int string_dash_match(const char *str, const char *tok) {
+    size_t tok_len;
+
+    if (!str || !tok || *tok == '\0') {
+        return 0;
+    }
+
+    tok_len = strlen(tok);
+    return !strcmp(str, tok) || (!strncmp(str, tok, tok_len) && str[tok_len] == '-');
+}
+
+/**
+ * Evaluate an attribute expression against an attribute.
+ */
+static int xnode_match_attribute(GumboAttribute *attribute,
+        XNodeAttributeSelector *selector) {
+
+    if (strcasecmp(attribute->name, selector->name) == 0) {
+        switch (selector->type) {
+        case XQSEL_ATTR_PRESENCE:
+            return 1;
+        case XQSEL_ATTR_EQUAL:
+            return !strcmp(attribute->value, selector->value);
+        case XQSEL_ATTR_SPACE_MATCH:     // ~=
+            return string_in_space_list(attribute->value, selector->value);
+        case XQSEL_ATTR_DASH_MATCH:      // |=
+            return string_dash_match(attribute->value, selector->value);
+        case XQSEL_ATTR_PREFIX_MATCH:    // ^=
+            return !strncmp(selector->value, attribute->value, strlen(selector->value));
+        case XQSEL_ATTR_SUFFIX_MATCH:    // $=
+            return string_ends_with(attribute->value, selector->value);
+        case XQSEL_ATTR_SUBSTRING_MATCH: // *=
+            return strstr(attribute->value, selector->value) != NULL;
+        default:
+            assert(0);
+            break;
+        }
+    }
+
+    return 0;
+}
+
+const char *xnode_get_tag_name(GumboNode *node, size_t *length) {
+    const char *data;
+
+    if (node->type == GUMBO_NODE_DOCUMENT) {
+        data = "document";
+        *length = sizeof("document") - 1;
+    }
+    else {
+        data = gumbo_normalized_tagname(node->v.element.tag);
+        *length = strlen(data);
+    }
+
+    if (*length == 0) {
+        GumboStringPiece tag = node->v.element.original_tag;
+        if (tag.data != NULL) {
+            gumbo_tag_from_original_text(&tag);
+            data = tag.data;
+            *length = tag.length;
+        }
+        else {
+            data = NULL;
+            *length = 0;
+        }
+    }
+
+    return data;
+}
+
+static int xnode_match_node_type(GumboNode *node, const char *type) {
+    const char *name;
+    size_t length;
+
+    if ((name = xnode_get_tag_name(node, &length))) {
+        if (!strcmp(type, "*")) {
+            return 1;
+        }
+        else {
+            if (strlen(type) == length) {
+                return !strncasecmp(name, type, length);
+            }
+        }
+    }
+
+    return 0;
+}
+
+int xnode_match_node(GumboNode *node, XNodeSelector *node_selector) {
+    GumboNodeType     type = node->type;
+    GumboVector      *attributes;
+    uint32_t          i, j;
+
+    if (type != GUMBO_NODE_ELEMENT && type != GUMBO_NODE_TEMPLATE) {
+        return 0;
+    }
+
+    if (!xnode_match_node_type(node, node_selector->type)) {
+        return 0;
+    }
+
+    attributes = &node->v.element.attributes;
+
+    for (i = 0; i < jsa_size(&node_selector->attributes); i++) {
+        XNodeAttributeSelector *selector;
+        selector = (XNodeAttributeSelector*) jsa_get(&node_selector->attributes, i);
+        for (j = 0; j < attributes->length; ++j) {
+            GumboAttribute* attribute = (GumboAttribute*) attributes->data[j];
+            if (xnode_match_attribute(attribute, selector)) break;
+        }
+        if (j == attributes->length) {
+            return 0;
+        }
+    }
+
+    return 1;
+}
+
+static void xnode_match_node_descendant(GumboNode* node, jsa_t *next_nodes,
+        XNodeSelector *selector) {
+    if (node->type == GUMBO_NODE_ELEMENT || node->type == GUMBO_NODE_TEMPLATE) {
+        uint32_t i;
+        for (i = 0; i < node->v.element.children.length; ++i) {
+            GumboNode* child = (GumboNode*) node->v.element.children.data[i];
+            if (xnode_match_node(child, selector)) {
+                jsa_push(next_nodes, child);
+            }
+            xnode_match_node_descendant(child, next_nodes, selector);
+        }
+    }
+}
+
+static void xnode_match_node_child(GumboNode* node, jsa_t *next_nodes,
+        XNodeSelector *selector) {
+    if (node->type == GUMBO_NODE_ELEMENT || node->type == GUMBO_NODE_TEMPLATE) {
+        uint32_t i;
+        for (i = 0; i < node->v.element.children.length; ++i) {
+            GumboNode* child = (GumboNode*) node->v.element.children.data[i];
+            if (xnode_match_node(child, selector)) {
+                jsa_push(next_nodes, child);
+            }
+        }
+    }
+}
+
+static void xnode_match_node_adjacent_sibling(GumboNode* node,
+        jsa_t *next_nodes, XNodeSelector *selector) {
+    if (node->type == GUMBO_NODE_ELEMENT || node->type == GUMBO_NODE_TEMPLATE) {
+        GumboNode *next = xnode_next(node, NULL);
+        if (next && xnode_match_node(next, selector)) {
+            jsa_push(next_nodes, next);
+        }
+    }
+}
+
+static void xnode_match_node_general_sibling(GumboNode* node, jsa_t *next_nodes,
+        XNodeSelector *selector) {
+
+    if (node->type == GUMBO_NODE_ELEMENT || node->type == GUMBO_NODE_TEMPLATE) {
+        while ((node = xnode_next(node, NULL))) {
+            if (xnode_match_node(node, selector)) {
+                jsa_push(next_nodes, node);
+            }
+        }
+    }
+}
+
+/*
+#include <stdio.h>
+static void xnode_dump(XNode *node) {
+    size_t name_size, html_size;
+    const char *name = xnode_type(node, &name_size);
+    const char *html = xnode_html(node, &html_size);
+    const char *id = xnode_attr(node, "id");
+    const char *Class = xnode_attr(node, "class");
+    printf("%s\t%s\t%s\t%.*s\n", name, id ? id : "", Class ? Class : "",
+        (int) html_size, html);
+}
+
+static void dump_query_result(const XNodeArray *result) {
+    if (result == NULL) {
+        printf("<null>\n");
+        return;
+    }
+    else {
+        uint32_t i;
+        printf("%u element(s):\n", result->size);
+        for (i = 0; i < result->size; i++) {
+            xnode_dump((XNode*) jsa_get(result, i));
+        }
+    }
+}
+*/
+#define SWAP(x, y) do { jsa_t *SWAP = x; x = y; y = SWAP; } while (0)
+
+const XNodeArray *xnode_query_execute(XNodeQuery *query, const XNode *node) {
+    uint32_t i, j;
+    jsa_t *prev_nodes = &query->result[0];
+    jsa_t *next_nodes = &query->result[1];
+
+    prev_nodes->size = 0;
+    jsa_push(prev_nodes, node);
+
+    for (i = 0; i < query->selectors.size; i++) {
+        XNodeSelector *selector = xnode_query_get_selector(query, i);
+
+        next_nodes->size = 0;
+
+        for (j = 0; j < jsa_size(prev_nodes); j++) {
+            GumboNode *node = (GumboNode*) jsa_get(prev_nodes, j);
+            switch (selector->combinator) {
+            case XQSEL_DESCENDANT:
+                xnode_match_node_descendant(node, next_nodes, selector);
+                break;
+            case XQSEL_CHILD:
+                xnode_match_node_child(node, next_nodes, selector);
+                break;
+            case XQSEL_ADJACENT_SIBLING:
+                xnode_match_node_adjacent_sibling(node, next_nodes, selector);
+                break;
+            case XQSEL_GENERAL_SIBLING:
+                xnode_match_node_general_sibling(node, next_nodes, selector);
+                break;
+            default:
+                assert(0);
+                break;
+            }
+        }
+
+        jsa_dedup(next_nodes);
+        // dump_query_result(next_nodes);
+        SWAP(prev_nodes, next_nodes);
+    }
+
+    return jsa_size(prev_nodes) > 0 ? prev_nodes : NULL;
+}
+
+XNodeSelector *xnode_query_selector(XNodeQuery *query, uint32_t n) {
+    return (XNodeSelector*) jsa_get(&query->selectors, n);
+}
+
+/**
+ * Locate the first instance of \btok\b in str, where \b = sep.
+ */
+char *strtok_simple(const char *str, const char *tok, char sep) {
+    const char *a, *b;
+    int flag;
+
+    b = tok;
+
+    if (*b == 0) {
+        return (char*) str;
+    }
+
+    for (flag = 1; *str != 0; str += 1) {
+        if (*str != *b || !flag) {
+            flag = sep ? (*str == sep) : (isspace(*str) || ispunct(*str));
+            continue;
+        }
+        a = str;
+        while (1) {
+            if (*b == 0) {
+                if (*a == 0 || (sep ? (*a == sep) : (isspace(*a)) || ispunct(*a))) {
+                    return (char*) str;
+                } else {
+                    break;
+                }
+            }
+            if (*a++ != *b++) {
+                break;
+            }
+        }
+        b = tok;
+    }
+    return (char *) 0;
+}

package/src/xnode_query.h

@@ -0,0 +1,186 @@
+#ifndef XNODE_QUERY_H_
+#define XNODE_QUERY_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef enum {
+    // 6.1. Type selector
+    // h1 element in the document tree: h1
+    XQSEL_TYPE,
+
+    // 6.2. Universal selector
+    // Represented by asterisk (*) any document type. '*' may be omitted in some cases.
+    XQSEL_UNIVERSAL,
+
+    // 6.3.1. Attribute presence and value selectors
+    // An E element with a "foo" attribute: E[foo]
+    XQSEL_ATTR_PRESENCE,
+
+    // An E element whose "foo" attribute value is exactly equal to "bar":
+    // E[foo="bar"]
+    XQSEL_ATTR_EQUAL,
+
+    // An E element whose "foo" attribute value is a list of whitespace-
+    // separated values, one of which is exactly equal to "bar": E[foo~="bar"]
+    XQSEL_ATTR_SPACE_MATCH,
+
+    // 6.3.2. Substring matching attribute selectors
+    // An E element whose "foo" attribute value begins exactly with the string
+    // "bar": E[foo^="bar"]
+    XQSEL_ATTR_PREFIX_MATCH,
+
+    // An E element whose "foo" attribute value ends exactly with the string
+    // "bar": E[foo$="bar"]
+    XQSEL_ATTR_SUFFIX_MATCH,
+
+    // An E element whose "foo" attribute value contains the substring "bar":
+    // E[foo*="bar"]
+    XQSEL_ATTR_SUBSTRING_MATCH,
+
+    // An E element whose "foo" attribute has a hyphen-separated list of values
+    // beginning (from the left) with "en": E[foo|="en"]
+    XQSEL_ATTR_DASH_MATCH,
+
+    // 6.4. Class selectors
+    // All elements with class~=pastoral: *.pastoral or just .pastoral
+    XQSEL_CLASS,
+
+    // 6.5. ID selectors
+    // Examples: h1#chapter1, #chapter1
+    XQSEL_ID,
+
+    // 6.6. Pseudo-classes (NOT SUPPORTED)
+    // A pseudo-class always consists of a "colon" (:) followed by the name of
+    // the pseudo-class and optionally by a value between parentheses.
+    // E.g. a:link, tr:nth-child(2n+1), :last-child, :first-of-type, etc.
+    XQSEL_PSEUDO_CLASS,
+
+    // 7. Pseudo-elements (NOT SUPPORTED)
+    // E.g. ::first-line, ::first-letter, ::before, ::after
+    XQSEL_PSEUDO_ELEMENT,
+
+    // 8. Combinators
+    // 8.1. Descendant combinator
+    // E.g. h1 em, div * p
+    XQSEL_DESCENDANT,
+
+    // 8.2. Child combinators
+    // E.g. body > p
+    XQSEL_CHILD,
+
+    // 8.3. Sibling combinators
+    // 8.3.1. Adjacent sibling combinator
+    // E.g. math + p (p element immediately following a math element)
+    XQSEL_ADJACENT_SIBLING,
+
+    // 8.3.2. General sibling combinator
+    // The elements represented by the two sequences share the same parent
+    // in the document tree and the element represented by the first sequence
+    // precedes (not necessarily immediately) the element represented by the
+    // second one. E.g.  h1 ~ pre (pre element following an h1)
+    XQSEL_GENERAL_SIBLING,
+
+    XQSEL_UNKNOWN_TYPE
+} XNodeQueryType;
+
+#include "gumbo.h"
+#include "jsa.h"
+
+typedef struct {
+    // One of the XQSEL_ATTR_* types
+    XNodeQueryType type;
+
+    // Attribute name
+    const char *name;
+
+    // Attribute value, if applicable
+    const char *value;
+} XNodeAttributeSelector;
+
+// 4. Selector syntax
+//
+// A selector is a chain of one or more sequences of simple selectors separated
+// by combinators. One pseudo-element may be appended to the last sequence of
+// simple selectors in a selector.
+//
+// A sequence of simple selectors is a chain of simple selectors that are not
+// separated by a combinator. It always begins with a type selector or a
+// universal selector. No other type selector or universal selector is allowed
+// in the sequence.
+//
+// A simple selector is either a type selector, universal selector, attribute
+// selector, class selector, ID selector, or pseudo-class.
+//
+typedef struct {
+    // Tag name for type selector, "*" for universal selector
+    const char *type;
+
+    // A list of attribute selectors; class selectors are translated as
+    // a list of {"class", "name", XQSEL_ATTR_SPACE_MATCH} selectors.
+    jsa_t attributes;
+
+    // Relation of this selector and the previous one, if any.
+    XNodeQueryType combinator;
+} XNodeSelector;
+
+typedef struct {
+    jsa_t selectors;
+    char *data;
+    jsa_t result[2];
+} XNodeQuery;
+
+typedef GumboNode XNode;
+
+typedef jsa_t XNodeArray;
+#define xnode_array_first(array)   ((XNode*)jsa_get((array),0))
+#define xnode_array_get(array,n)   ((XNode*)jsa_get((array),(n)))
+#define xnode_array_size(array)    jsa_size(array)
+
+typedef struct {
+    GumboOutput *output;
+    GumboOptions parse_options;
+    char *html;
+    size_t html_length;
+} XNodeDocument;
+
+XNodeQuery       *xnode_query_create(const char *, const char **, int *);
+const XNodeArray *xnode_query_execute(XNodeQuery *, const XNode*);
+void              xnode_query_free(XNodeQuery *);
+XNodeSelector    *xnode_query_selector(XNodeQuery*, uint32_t);
+
+#define xnode_query_get_selector(q,i) ((XNodeSelector*)jsa_get(&q->selectors,i))
+
+XNodeDocument *xnode_parse_html(const char *html, size_t length);
+const XNode   *xnode_document_root(const XNodeDocument*);
+void           xnode_document_free(XNodeDocument*);
+
+const char    *xnode_attr(const XNode*, const char *name);
+
+XNode *xnode_first_child(XNode *node, XNodeSelector *selector);
+XNode *xnode_parent(XNode *node);
+XNode *xnode_prev(XNode *node, XNodeSelector *selector);
+XNode *xnode_prev_check(XNode *node, XNodeSelector *selector);
+XNode *xnode_next(XNode *node, XNodeSelector *selector);
+XNode *xnode_next_check(XNode *node, XNodeSelector *selector);
+const char *xnode_html(XNode *node, size_t *length);
+const char *xnode_text(XNode *xnode);
+const char *xnode_type(XNode *node, size_t *length);
+int xnode_has_class(XNode *xnode, const char *class_name);
+int xnode_has_attr(XNode *xnode, const char *name);
+
+int xnode_match_node(GumboNode *node, XNodeSelector *selector);
+GumboVector *xnode_children(XNode *node);
+
+// utils
+char *strtok_simple(const char *str, const char *tok, char sep);
+#define xmalloc malloc
+#define xnew(type) ((type*)xmalloc(sizeof (type)))
+#define xfree free
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // XNODE_QUERY_H_