gumbo-html 0.2.3 → 0.3.0

package/src/html_element.h

@@ -0,0 +1,70 @@
+#ifndef HTML_ELEMENT_H_
+#define HTML_ELEMENT_H_
+
+#include <napi.h>
+
+#include <string>
+
+#include "xnode_query.h"
+
+namespace html {
+
+class Document;
+struct XDocWrapper;
+
+class Element : public Napi::ObjectWrap<Element> {
+public:
+  static void Init(Napi::Env env);
+  static Napi::FunctionReference constructor;
+
+  static Napi::Value Query(Napi::Env env, XDocWrapper *wrapper,
+                           const XNode *node, const char *selector);
+  static Napi::Value Create(Napi::Env env, XDocWrapper *xdoc, XNode *xnode);
+  Element(const Napi::CallbackInfo& info);
+  ~Element();
+
+  Napi::Value Attr(const Napi::CallbackInfo& info);
+  Napi::Value AttrSafe(const Napi::CallbackInfo& info);
+  Napi::Value Find(const Napi::CallbackInfo& info);
+  Napi::Value First(const Napi::CallbackInfo& info);
+  Napi::Value FirstSafe(const Napi::CallbackInfo& info);
+  Napi::Value Only(const Napi::CallbackInfo& info);
+  Napi::Value OnlySafe(const Napi::CallbackInfo& info);
+  Napi::Value HasClass(const Napi::CallbackInfo& info);
+  Napi::Value HasAttribute(const Napi::CallbackInfo& info);
+  Napi::Value Next(const Napi::CallbackInfo& info);
+  Napi::Value Prev(const Napi::CallbackInfo& info);
+
+  Napi::Value GetTagName(const Napi::CallbackInfo& info);
+  Napi::Value GetInnerText(const Napi::CallbackInfo& info);
+  Napi::Value GetOuterHTML(const Napi::CallbackInfo& info);
+  Napi::Value GetParent(const Napi::CallbackInfo& info);
+  Napi::Value GetNodeType(const Napi::CallbackInfo& info);
+  Napi::Value GetChildNodes(const Napi::CallbackInfo& info);
+
+  Napi::Value FirstOrThrow(const Napi::CallbackInfo& info);
+  Napi::Value OnlyOrThrow(const Napi::CallbackInfo& info);
+  Napi::Value AttrOrThrow(const Napi::CallbackInfo& info);
+  Napi::Value Text(const Napi::CallbackInfo& info);
+  Napi::Value TextOrThrow(const Napi::CallbackInfo& info);
+  Napi::Value Exists(const Napi::CallbackInfo& info);
+  Napi::Value Count(const Napi::CallbackInfo& info);
+  Napi::Value Closest(const Napi::CallbackInfo& info);
+  Napi::Value Children(const Napi::CallbackInfo& info);
+  Napi::Value Siblings(const Napi::CallbackInfo& info);
+  Napi::Value Matches(const Napi::CallbackInfo& info);
+  Napi::Value Is(const Napi::CallbackInfo& info);
+  Napi::Value Rows(const Napi::CallbackInfo& info);
+  Napi::Value GetTextContent(const Napi::CallbackInfo& info);
+
+  XNode *xnode_;
+  XDocWrapper *xdoc_;
+};
+
+std::string get_inner_text(GumboNode *node);
+std::string normalize_whitespace(const std::string &s);
+std::string join_text_with_separator(XNode *node, const std::string &sep);
+
+}
+
+#endif // HTML_ELEMENT_H_

package/src/include/win/strings.h

@@ -0,0 +1,11 @@
+#ifndef NODE_HTML_STRINGS_H_
+#define NODE_HTML_STRINGS_H_
+
+#ifdef _WIN32
+#include <string.h>
+#define strcasecmp _stricmp
+#define strncasecmp _strnicmp
+#endif
+
+#endif // NODE_HTML_STRINGS_H_
+

package/src/jsa.c

@@ -0,0 +1,182 @@
+/*
+ * Copyright (C) Weidong Fang
+ * 
+ * Email: wdfang@gmail.com
+ *
+ * Last updated: 2014/06/28
+ */
+
+#include "jsa.h"
+
+#include <assert.h>
+#include <stdlib.h>
+#include <string.h>
+
+#define xmalloc         malloc
+#define xrealloc        realloc
+#define xfree           free
+
+#define JSA_MAX_SIZE    1048576
+#define JSA_OK          0
+#define JSA_ERROR      -1
+
+jsa_t *jsa_create() {
+    jsa_t *a = (jsa_t*)xmalloc(sizeof(jsa_t));
+    jsa_init(a);
+    return a;
+}
+
+void jsa_init(jsa_t *a) {
+    a->size = 0;
+    a->item = NULL;
+    a->alloc_size = 0;
+}
+
+int jsa_alloc(jsa_t * a, uint32_t size) {
+    if (a->alloc_size < size) {
+        void *item;
+
+        if ((size = ((size + 31) / 32) * 32) > JSA_MAX_SIZE) {
+            return JSA_ERROR;
+        }
+
+        item = xrealloc(a->item, size * sizeof(JSA_TYPE));
+
+        if (item == NULL ) {
+            return JSA_ERROR;
+        }
+
+        a->item = (JSA_TYPE*) item;
+        a->alloc_size = size;
+    }
+
+    return JSA_OK;
+}
+
+void jsa_clean(jsa_t *a) {
+    if (a->alloc_size > 0) {
+        xfree(a->item);
+        a->item = NULL;
+        a->alloc_size = 0;
+        a->size = 0;
+    }
+}
+
+void jsa_free(jsa_t * a) {
+    jsa_clean(a);
+    xfree(a);
+}
+
+void jsa_free_ex(jsa_t * a, void (*free_item)(JSA_TYPE)) {
+	if (free_item) {
+		uint32_t i;
+		for (i = 0; i < a->size; i++) {
+			(*free_item)(a->item[i]);
+		}
+	}
+	jsa_clean(a);
+    xfree(a);
+}
+
+void jsa_append(jsa_t *a, JSA_TYPE m) {
+    if (a->size >= a->alloc_size) {
+        jsa_alloc(a, a->size + 1);
+    }
+    assert (a->size < a->alloc_size);
+    a->item[a->size++] = m;
+}
+
+JSA_TYPE jsa_pop(jsa_t *a) {
+    assert(a->size > 0);
+    return a->item[--a->size];
+}
+
+int jsa_resize(jsa_t *a, uint32_t size) {
+    if (size > a->alloc_size) {
+        if (jsa_alloc(a, size) != JSA_OK) {
+        	return JSA_ERROR;
+        }
+        memset(a->item + a->size, 0, (size - a->size) * sizeof(a->item[0]));
+    }
+    else if (size < a->size) {
+        memset(a->item + size, 0, (a->size - size) * sizeof(a->item[0]));
+    }
+
+    a->size = size;
+
+    return JSA_OK;
+}
+
+void jsa_insert(jsa_t *a, uint32_t index, JSA_TYPE m) {
+    if (index >= a->size) {
+        jsa_resize(a, index + 1);
+        a->item[index] = m;
+    } else {
+        memmove(&a->item[index + 1], &a->item[index],
+                (a->size - index) * sizeof(a->item[0]));
+        a->item[index] = m;
+        a->size++;
+    }
+}
+
+void jsa_dedup(jsa_t *a) {
+    uint32_t i, j, k, n = a->size;
+
+    for (i = 0; i < n; i++) {
+        for (j = i + 1; j < n;) {
+            if (a->item[j] == a->item[i]) {
+                for (k = j; k < n; k++) {
+                    a->item[k] = a->item[k + 1];
+                }
+                n--;
+            } else {
+                j++;
+            }
+        }
+    }
+
+    if (n != a->size) {
+        jsa_resize(a, n);
+    }
+}
+
+jsa_t *jsa_clear(jsa_t *a) {
+    jsa_resize(a, 0);
+    return a;
+}
+
+#if TEST_DEDUP
+
+#include <stdio.h>
+
+int main() {
+    jsa_t *a = jsa_create();
+    int i, n;
+
+    printf("Enter array elements (-1 to stop):\n");
+    while (1) {
+        scanf("%d", &n);
+        if (n == -1) break;
+        jsa_push(a, (void*)(uintptr_t)n);
+    }
+
+    for (i = 0; i < (int)jsa_size(a); i++) {
+        printf("%lu ", (unsigned long)jsa_get(a, i));
+    }
+
+    printf("\n");
+
+    jsa_dedup(a);
+
+    for (i = 0; i < (int)jsa_size(a); i++) {
+        printf("%lu ", (unsigned long)jsa_get(a, i));
+    }
+
+    printf("\n");
+
+    jsa_free(a);
+
+    return 0;
+}
+#endif
+

package/src/jsa.h

@@ -0,0 +1,44 @@
+#ifndef _JSA_H_
+#define _JSA_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdint.h>
+
+#ifndef JSA_TYPE
+#define JSA_TYPE uintptr_t
+#endif
+
+typedef struct {
+    JSA_TYPE *item;
+    uint32_t   size;
+    uint32_t   alloc_size;
+} jsa_t;
+
+jsa_t *jsa_create();
+void jsa_init(jsa_t *);
+void jsa_clean(jsa_t *);
+void jsa_free(jsa_t *);
+void jsa_free_ex(jsa_t * a, void (*free_item)(JSA_TYPE));
+void jsa_append(jsa_t *, JSA_TYPE m);
+JSA_TYPE jsa_pop(jsa_t *) ;
+void jsa_insert(jsa_t *, uint32_t, JSA_TYPE);
+int jsa_alloc(jsa_t * a, uint32_t size);
+int jsa_resize(jsa_t * a, uint32_t size);
+void jsa_dedup(jsa_t * a);
+
+#define jsa_get(a,i) ((a)->item[i])
+#define jsa_set(a, i, v) ((a)->item[i]=v)
+#define jsa_push(a,p) jsa_append(a,(JSA_TYPE)p)
+#define jsa_first(a) ((a)->size ? (a)->item[0] : 0)
+#define jsa_last(a) ((a)->size ? (a)->item[(a)->size - 1] : 0)
+#define jsa_size(a) ((a)->size)
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _JSA_H_ */
+

package/src/xnode.c

@@ -0,0 +1,372 @@
+#include "xnode_query.h"
+
+#include <ctype.h>
+#include <string.h>
+#include <stdlib.h>
+
+GumboVector *xnode_children(XNode *node) {
+    if (!node) {
+        return NULL;
+    }
+
+    switch (node->type) {
+    case GUMBO_NODE_DOCUMENT:
+        return &node->v.document.children;
+    case GUMBO_NODE_ELEMENT:
+    case GUMBO_NODE_TEMPLATE:
+        return &node->v.element.children;
+    default:
+        return NULL;
+    }
+}
+
+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 XNodeDocument *xnode_parse_html_real(const char *html, size_t length,
+        int copy_html) {
+    XNodeDocument *doc = xnew(XNodeDocument);
+
+    if (copy_html) {
+        doc->html = (char*) xmalloc(length + 1);
+        memcpy(doc->html, html, length);
+        doc->html[length] = '\0';
+    } else {
+        doc->html = (char*) html;
+    }
+
+    doc->html_length = length;
+    doc->parse_options = kGumboDefaultOptions;
+    doc->output = gumbo_parse_with_options(&doc->parse_options, doc->html, length);
+
+    return doc;
+}
+
+XNodeDocument *xnode_parse_html(const char *html, size_t length) {
+    return xnode_parse_html_real(html, length, 1);
+}
+
+const XNode *xnode_document_root(const XNodeDocument *document) {
+    return document->output->root;
+}
+
+void xnode_document_free(XNodeDocument *doc) {
+    gumbo_destroy_output(&doc->parse_options, doc->output);
+    xfree(doc->html);
+    xfree(doc);
+}
+
+const char *xnode_attr(const XNode *node, const char *name) {
+    GumboAttribute *attr;
+    if (node->type == GUMBO_NODE_ELEMENT || node->type == GUMBO_NODE_TEMPLATE) {
+        if ((attr = gumbo_get_attribute(&node->v.element.attributes, name))) {
+            return attr->value;
+        }
+    }
+    return NULL;
+}
+
+int xnode_match_node(GumboNode *node, XNodeSelector *selector);
+
+XNode *xnode_first_child(XNode *node, XNodeSelector *selector) {
+    uint32_t i;
+    GumboVector *children = xnode_children(node);
+
+    if (!children) {
+        return NULL;
+    }
+
+    for (i = 0; i < children->length; ++i) {
+        GumboNode* child = (GumboNode*) children->data[i];
+        if (child->type != GUMBO_NODE_ELEMENT &&
+                child->type != GUMBO_NODE_TEMPLATE) continue;
+        if (!selector || xnode_match_node(child, selector)) {
+            return child;
+        }
+    }
+
+    return NULL;
+}
+
+XNode *xnode_first_child_check(XNode *node, XNodeSelector *selector) {
+    XNode *child = xnode_first_child(node, NULL);
+    return child != NULL && xnode_match_node(child, selector) ? child : NULL;
+}
+
+XNode *xnode_parent(XNode *node) {
+    return node->parent;
+}
+
+XNode *xnode_prev(XNode *node, XNodeSelector *selector) {
+    GumboNode *parent = node->parent;
+    GumboVector *children = xnode_children(parent);
+    size_t i;
+
+    if (!children) {
+        return NULL;
+    }
+
+    for (i = node->index_within_parent; i > 0; i--) {
+        node = (GumboNode*) children->data[i - 1];
+        if (node->type != GUMBO_NODE_ELEMENT &&
+                node->type != GUMBO_NODE_TEMPLATE) continue;
+        if (!selector || xnode_match_node(node, selector)) {
+            return node;
+        }
+    }
+
+    return NULL;
+}
+
+XNode *xnode_prev_check(XNode *node, XNodeSelector *selector) {
+    XNode *prev = xnode_prev(node, NULL);
+    return prev != NULL && xnode_match_node(prev, selector) ? prev : NULL;
+}
+
+XNode *xnode_next(XNode *node, XNodeSelector *selector) {
+    GumboNode *parent = node->parent;
+    GumboVector *children = xnode_children(parent);
+    size_t i = node->index_within_parent;
+
+    if (!children) {
+        return NULL;
+    }
+
+    for (; i + 1 < children->length; i++) {
+        node = (GumboNode*) children->data[i + 1];
+        if (node->type != GUMBO_NODE_ELEMENT &&
+                node->type != GUMBO_NODE_TEMPLATE) continue;
+        if (!selector || xnode_match_node(node, selector)) {
+            return node;
+        }
+    }
+
+    return NULL;
+}
+
+XNode *xnode_next_check(XNode *node, XNodeSelector *selector) {
+    XNode *next = xnode_next(node, NULL);
+    return next != NULL && xnode_match_node(next, selector) ? next : NULL;
+}
+
+static const char *max_ptr(const char *a, const char *b) {
+    if (!a) {
+        return b;
+    }
+    if (!b) {
+        return a;
+    }
+    return b > a ? b : a;
+}
+
+static const char *min_ptr(const char *a, const char *b) {
+    if (!a) {
+        return b;
+    }
+    if (!b) {
+        return a;
+    }
+    return b < a ? b : a;
+}
+
+static XNode *xnode_next_any(XNode *node) {
+    GumboVector *children;
+
+    if (!node || !node->parent) {
+        return NULL;
+    }
+
+    children = xnode_children(node->parent);
+    if (!children || node->index_within_parent + 1 >= children->length) {
+        return NULL;
+    }
+
+    return (XNode*) children->data[node->index_within_parent + 1];
+}
+
+static const char *xnode_source_start(XNode *node) {
+    if (!node) {
+        return NULL;
+    }
+
+    switch (node->type) {
+    case GUMBO_NODE_ELEMENT:
+    case GUMBO_NODE_TEMPLATE:
+        return node->v.element.original_tag.data;
+    default:
+        return node->v.text.original_text.data;
+    }
+}
+
+static const char *xnode_implicit_end_boundary(XNode *node) {
+    const char *start = node->v.element.original_tag.data;
+    const char *boundary = xnode_source_start(xnode_next_any(node));
+    XNode *parent = node->parent;
+
+    while (parent) {
+        if ((parent->type == GUMBO_NODE_ELEMENT ||
+                    parent->type == GUMBO_NODE_TEMPLATE) &&
+                parent->v.element.original_end_tag.data &&
+                parent->v.element.original_end_tag.data > start) {
+            boundary = min_ptr(boundary, parent->v.element.original_end_tag.data);
+        }
+        parent = parent->parent;
+    }
+
+    return boundary;
+}
+
+static const char *xnode_subtree_end(XNode *node) {
+    const char *end = NULL;
+
+    if (!node) {
+        return NULL;
+    }
+
+    switch (node->type) {
+    case GUMBO_NODE_DOCUMENT: {
+        GumboVector *children = xnode_children(node);
+        uint32_t i;
+        for (i = 0; children && i < children->length; ++i) {
+            end = max_ptr(end, xnode_subtree_end((XNode*) children->data[i]));
+        }
+        return end;
+    }
+    case GUMBO_NODE_ELEMENT:
+    case GUMBO_NODE_TEMPLATE: {
+        GumboElement *element = &node->v.element;
+        GumboVector *children = xnode_children(node);
+        uint32_t i;
+
+        if (element->original_tag.data) {
+            end = element->original_tag.data + element->original_tag.length;
+        }
+
+        for (i = 0; children && i < children->length; ++i) {
+            end = max_ptr(end, xnode_subtree_end((XNode*) children->data[i]));
+        }
+
+        if (element->original_end_tag.data) {
+            end = max_ptr(end,
+                    element->original_end_tag.data + element->original_end_tag.length);
+        }
+
+        return end;
+    }
+    default:
+        if (node->v.text.original_text.data) {
+            return node->v.text.original_text.data + node->v.text.original_text.length;
+        }
+        return NULL;
+    }
+}
+
+static const char *xnode_html_element(XNode *node, size_t *length) {
+    GumboElement *element = &node->v.element;
+    *length = 0;
+    if (element->original_tag.length > 0) {
+        const char *end = NULL;
+        if (element->end_pos.offset > element->start_pos.offset) {
+            end = element->original_tag.data +
+                  (element->end_pos.offset - element->start_pos.offset);
+            if (element->original_end_tag.length > 0) {
+                end += element->original_end_tag.length;
+            }
+        }
+        else {
+            end = xnode_subtree_end(node);
+        }
+        if (element->original_end_tag.length == 0) {
+            end = min_ptr(end, xnode_implicit_end_boundary(node));
+        }
+        if (end && end >= element->original_tag.data) {
+            *length = end - element->original_tag.data;
+        }
+        if (*length == 0) {
+            *length = element->original_tag.length;
+        }
+        return element->original_tag.data;
+    }
+    else {
+        return "";
+    }
+}
+
+const char *xnode_html(XNode *node, size_t *length) {
+    switch(node->type) {
+    case GUMBO_NODE_DOCUMENT:
+        *length = 0;
+        return "";
+    case GUMBO_NODE_ELEMENT:
+        return xnode_html_element(node, length);
+    default:
+        *length = node->v.text.original_text.length;
+        return node->v.text.original_text.data;
+    }
+}
+
+/**
+ * Returns the text content of the first GUMBO_NODE_TEXT child.
+ */
+const char *xnode_text(XNode *node) {
+    uint32_t i;
+
+    for (i = 0; i < node->v.element.children.length; ++i) {
+        GumboNode* child = (GumboNode*) node->v.element.children.data[i];
+        if (child->type == GUMBO_NODE_TEXT) {
+            return child->v.text.text;
+        }
+    }
+
+    return NULL;
+}
+
+const char *xnode_get_tag_name(GumboNode *node, size_t *length);
+
+const char *xnode_type(XNode *node, size_t *length) {
+    return xnode_get_tag_name(node, length);
+}
+
+int xnode_has_class(XNode *node, const char *class_name) {
+    GumboAttribute *attr;
+    if (node->type == GUMBO_NODE_ELEMENT || node->type == GUMBO_NODE_TEMPLATE) {
+        if ((attr = gumbo_get_attribute(&node->v.element.attributes, "class"))) {
+            return string_in_space_list(attr->value, class_name) ? 1 : 0;
+        }
+    }
+    return 0;
+}
+
+int xnode_has_attr(XNode *node, const char *name) {
+    if (node->type == GUMBO_NODE_ELEMENT || node->type == GUMBO_NODE_TEMPLATE) {
+        return gumbo_get_attribute(&node->v.element.attributes, name) ? 1 : 0;
+    }
+    return 0;
+}