gumbo-html 0.2.4 → 0.3.0

package/src/gumbo-parser/src/util.h

@@ -0,0 +1,60 @@
+// Copyright 2010 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Author: jdtang@google.com (Jonathan Tang)
+//
+// This contains some utility functions that didn't fit into any of the other
+// headers.
+
+#ifndef GUMBO_UTIL_H_
+#define GUMBO_UTIL_H_
+#ifdef _MSC_VER
+#define _CRT_SECURE_NO_WARNINGS
+#endif
+#include <stdbool.h>
+#include <stddef.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// Forward declaration since it's passed into some of the functions in this
+// header.
+struct GumboInternalParser;
+
+// Utility function for allocating & copying a null-terminated string into a
+// freshly-allocated buffer.  This is necessary for proper memory management; we
+// have the convention that all const char* in parse tree structures are
+// freshly-allocated, so if we didn't copy, we'd try to delete a literal string
+// when the parse tree is destroyed.
+char* gumbo_copy_stringz(struct GumboInternalParser* parser, const char* str);
+
+// Allocate a chunk of memory, using the allocator specified in the Parser's
+// config options.
+void* gumbo_parser_allocate(
+    struct GumboInternalParser* parser, size_t num_bytes);
+
+// Deallocate a chunk of memory, using the deallocator specified in the Parser's
+// config options.
+void gumbo_parser_deallocate(struct GumboInternalParser* parser, void* ptr);
+
+// Debug wrapper for printf, to make it easier to turn off debugging info when
+// required.
+void gumbo_debug(const char* format, ...);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // GUMBO_UTIL_H_

package/src/gumbo-parser/src/vector.c

@@ -0,0 +1,123 @@
+// Copyright 2010 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Author: jdtang@google.com (Jonathan Tang)
+
+#include "vector.h"
+
+#include <assert.h>
+#include <stdlib.h>
+#include <string.h>
+#include <strings.h>
+
+#include "util.h"
+
+struct GumboInternalParser;
+
+const GumboVector kGumboEmptyVector = {NULL, 0, 0};
+
+void gumbo_vector_init(struct GumboInternalParser* parser,
+    size_t initial_capacity, GumboVector* vector) {
+  vector->length = 0;
+  vector->capacity = initial_capacity;
+  if (initial_capacity > 0) {
+    vector->data =
+        gumbo_parser_allocate(parser, sizeof(void*) * initial_capacity);
+  } else {
+    vector->data = NULL;
+  }
+}
+
+void gumbo_vector_destroy(
+    struct GumboInternalParser* parser, GumboVector* vector) {
+  if (vector->capacity > 0) {
+    gumbo_parser_deallocate(parser, vector->data);
+  }
+}
+
+static void enlarge_vector_if_full(
+    struct GumboInternalParser* parser, GumboVector* vector) {
+  if (vector->length >= vector->capacity) {
+    if (vector->capacity) {
+      size_t old_num_bytes = sizeof(void*) * vector->capacity;
+      vector->capacity *= 2;
+      size_t num_bytes = sizeof(void*) * vector->capacity;
+      void** temp = gumbo_parser_allocate(parser, num_bytes);
+      memcpy(temp, vector->data, old_num_bytes);
+      gumbo_parser_deallocate(parser, vector->data);
+      vector->data = temp;
+    } else {
+      // 0-capacity vector; no previous array to deallocate.
+      vector->capacity = 2;
+      vector->data =
+          gumbo_parser_allocate(parser, sizeof(void*) * vector->capacity);
+    }
+  }
+}
+
+void gumbo_vector_add(
+    struct GumboInternalParser* parser, void* element, GumboVector* vector) {
+  enlarge_vector_if_full(parser, vector);
+  assert(vector->data);
+  assert(vector->length < vector->capacity);
+  vector->data[vector->length++] = element;
+}
+
+void* gumbo_vector_pop(
+    struct GumboInternalParser* parser, GumboVector* vector) {
+  if (vector->length == 0) {
+    return NULL;
+  }
+  return vector->data[--vector->length];
+}
+
+int gumbo_vector_index_of(GumboVector* vector, const void* element) {
+  for (unsigned int i = 0; i < vector->length; ++i) {
+    if (vector->data[i] == element) {
+      return i;
+    }
+  }
+  return -1;
+}
+
+void gumbo_vector_insert_at(struct GumboInternalParser* parser, void* element,
+    unsigned int index, GumboVector* vector) {
+  assert(index >= 0);
+  assert(index <= vector->length);
+  enlarge_vector_if_full(parser, vector);
+  ++vector->length;
+  memmove(&vector->data[index + 1], &vector->data[index],
+      sizeof(void*) * (vector->length - index - 1));
+  vector->data[index] = element;
+}
+
+void gumbo_vector_remove(
+    struct GumboInternalParser* parser, void* node, GumboVector* vector) {
+  int index = gumbo_vector_index_of(vector, node);
+  if (index == -1) {
+    return;
+  }
+  gumbo_vector_remove_at(parser, index, vector);
+}
+
+void* gumbo_vector_remove_at(struct GumboInternalParser* parser,
+    unsigned int index, GumboVector* vector) {
+  assert(index >= 0);
+  assert(index < vector->length);
+  void* result = vector->data[index];
+  memmove(&vector->data[index], &vector->data[index + 1],
+      sizeof(void*) * (vector->length - index - 1));
+  --vector->length;
+  return result;
+}

package/src/gumbo-parser/src/vector.h

@@ -0,0 +1,67 @@
+// Copyright 2010 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Author: jdtang@google.com (Jonathan Tang)
+
+#ifndef GUMBO_VECTOR_H_
+#define GUMBO_VECTOR_H_
+
+#include "gumbo.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// Forward declaration since it's passed into some of the functions in this
+// header.
+struct GumboInternalParser;
+
+// Initializes a new GumboVector with the specified initial capacity.
+void gumbo_vector_init(struct GumboInternalParser* parser,
+    size_t initial_capacity, GumboVector* vector);
+
+// Frees the memory used by an GumboVector.  Does not free the contained
+// pointers.
+void gumbo_vector_destroy(
+    struct GumboInternalParser* parser, GumboVector* vector);
+
+// Adds a new element to an GumboVector.
+void gumbo_vector_add(
+    struct GumboInternalParser* parser, void* element, GumboVector* vector);
+
+// Removes and returns the element most recently added to the GumboVector.
+// Ownership is transferred to caller.  Capacity is unchanged.  If the vector is
+// empty, NULL is returned.
+void* gumbo_vector_pop(struct GumboInternalParser* parser, GumboVector* vector);
+
+// Inserts an element at a specific index.  This is potentially O(N) time, but
+// is necessary for some of the spec's behavior.
+void gumbo_vector_insert_at(struct GumboInternalParser* parser, void* element,
+    unsigned int index, GumboVector* vector);
+
+// Removes an element from the vector, or does nothing if the element is not in
+// the vector.
+void gumbo_vector_remove(
+    struct GumboInternalParser* parser, void* element, GumboVector* vector);
+
+// Removes and returns an element at a specific index.  Note that this is
+// potentially O(N) time and should be used sparingly.
+void* gumbo_vector_remove_at(struct GumboInternalParser* parser,
+    unsigned int index, GumboVector* vector);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // GUMBO_VECTOR_H_

package/src/html_document.cc

@@ -0,0 +1,411 @@
+#include "html_document.h"
+#include "html_element.h"
+
+#include <cstring>
+#include <string>
+
+namespace html {
+
+Napi::FunctionReference Document::constructor;
+
+namespace {
+
+bool GetStringArg(const Napi::CallbackInfo& info, size_t index,
+                  const char *name, std::string *value) {
+  Napi::Env env = info.Env();
+  if (info.Length() <= index || !info[index].IsString()) {
+    Napi::TypeError::New(env, std::string(name) + " must be a string")
+        .ThrowAsJavaScriptException();
+    return false;
+  }
+  *value = info[index].As<Napi::String>().Utf8Value();
+  return true;
+}
+
+bool HasDocument(const Napi::CallbackInfo& info, Document *doc) {
+  if (doc->xdoc_wrapper_ && doc->xdoc_wrapper_->xdoc) {
+    return true;
+  }
+  Napi::Error::New(info.Env(), "Invalid document").ThrowAsJavaScriptException();
+  return false;
+}
+
+class QueryHandle {
+public:
+  explicit QueryHandle(const char *selector)
+      : query_(selector ? xnode_query_create(selector, NULL, NULL) : nullptr) {}
+
+  ~QueryHandle() {
+    if (query_) {
+      xnode_query_free(query_);
+    }
+  }
+
+  XNodeQuery *get() const { return query_; }
+
+private:
+  XNodeQuery *query_;
+};
+
+} // namespace
+
+Document::Document(const Napi::CallbackInfo& info)
+    : Napi::ObjectWrap<Document>(info), xdoc_wrapper_(nullptr) {
+
+  std::string html;
+  if (!GetStringArg(info, 0, "html", &html)) {
+    return;
+  }
+  XNodeDocument *xdoc = xnode_parse_html(html.c_str(), html.size());
+  xdoc_wrapper_ = new XDocWrapper(xdoc);
+}
+
+Document::~Document() {
+  if (xdoc_wrapper_ && (--xdoc_wrapper_->ref_count == 0)) {
+    delete xdoc_wrapper_;
+  }
+}
+
+Napi::Value Document::GetDocumentElement(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  Document* xdoc = Document::Unwrap(info.This().As<Napi::Object>());
+  if (!HasDocument(info, xdoc)) {
+    return env.Undefined();
+  }
+  XNode *root = (XNode*) xnode_document_root(xdoc->xdoc_wrapper_->xdoc);
+  return Element::Create(env, xdoc->xdoc_wrapper_, root);
+}
+
+void Document::Init(Napi::Env env) {
+  Napi::Function func = DefineClass(env, "Document", {
+    InstanceMethod("find", &Document::Find),
+    InstanceMethod("first", &Document::First),
+    InstanceMethod("first_s", &Document::FirstSafe),
+    InstanceMethod("only", &Document::Only),
+    InstanceMethod("only_s", &Document::OnlySafe),
+    InstanceAccessor("documentElement", &Document::GetDocumentElement, nullptr),
+
+    InstanceMethod("firstOrThrow", &Document::FirstOrThrow),
+    InstanceMethod("onlyOrThrow", &Document::OnlyOrThrow),
+    InstanceMethod("text", &Document::Text),
+    InstanceMethod("textOrThrow", &Document::TextOrThrow),
+    InstanceMethod("exists", &Document::Exists),
+    InstanceMethod("count", &Document::Count),
+    InstanceMethod("attr", &Document::Attr2),
+    InstanceMethod("attrOrThrow", &Document::AttrOrThrow2),
+  });
+
+  constructor = Napi::Persistent(func);
+  constructor.SuppressDestruct();
+}
+
+Napi::Value Document::Find(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  Document* xdoc = Document::Unwrap(info.This().As<Napi::Object>());
+  if (!HasDocument(info, xdoc)) {
+    return env.Undefined();
+  }
+  std::string selector;
+  if (!GetStringArg(info, 0, "selector", &selector)) {
+    return env.Undefined();
+  }
+  XNode *root = (XNode*) xnode_document_root(xdoc->xdoc_wrapper_->xdoc);
+  return Element::Query(env, xdoc->xdoc_wrapper_, root, selector.c_str());
+}
+
+Napi::Value Document::First(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  Napi::HandleScope scope(env);
+  Document* xdoc = Document::Unwrap(info.This().As<Napi::Object>());
+  if (!HasDocument(info, xdoc)) {
+    return env.Undefined();
+  }
+  std::string selector;
+  if (!GetStringArg(info, 0, "selector", &selector)) {
+    return env.Undefined();
+  }
+  XNode *root = (XNode*) xnode_document_root(xdoc->xdoc_wrapper_->xdoc);
+  Napi::Value value = Element::Query(env, xdoc->xdoc_wrapper_, root, selector.c_str());
+  if (!value.IsArray()) {
+    return env.Undefined();
+  }
+  Napi::Array array = value.As<Napi::Array>();
+  if (array.Length() > 0) {
+    return array.Get(uint32_t(0));
+  }
+  return env.Null();
+}
+
+Napi::Value Document::FirstSafe(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  Napi::HandleScope scope(env);
+  Document* xdoc = Document::Unwrap(info.This().As<Napi::Object>());
+  if (!HasDocument(info, xdoc)) {
+    return env.Undefined();
+  }
+  std::string selector;
+  if (!GetStringArg(info, 0, "selector", &selector)) {
+    return env.Undefined();
+  }
+  XNode *root = (XNode*) xnode_document_root(xdoc->xdoc_wrapper_->xdoc);
+  Napi::Value value = Element::Query(env, xdoc->xdoc_wrapper_, root, selector.c_str());
+  if (!value.IsArray()) {
+    return env.Undefined();
+  }
+  Napi::Array array = value.As<Napi::Array>();
+  if (array.Length() > 0) {
+    return array.Get(uint32_t(0));
+  }
+  Napi::Error::New(env, "No element found").ThrowAsJavaScriptException();
+  return env.Undefined();
+}
+
+Napi::Value Document::Only(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  Napi::HandleScope scope(env);
+  Document* xdoc = Document::Unwrap(info.This().As<Napi::Object>());
+  if (!HasDocument(info, xdoc)) {
+    return env.Undefined();
+  }
+  std::string selector;
+  if (!GetStringArg(info, 0, "selector", &selector)) {
+    return env.Undefined();
+  }
+  XNode *root = (XNode*) xnode_document_root(xdoc->xdoc_wrapper_->xdoc);
+  Napi::Value value = Element::Query(env, xdoc->xdoc_wrapper_, root, selector.c_str());
+  if (!value.IsArray()) {
+    return env.Undefined();
+  }
+  Napi::Array array = value.As<Napi::Array>();
+  if (array.Length() == 1) {
+    return array.Get(uint32_t(0));
+  }
+  return env.Null();
+}
+
+Napi::Value Document::OnlySafe(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  Napi::HandleScope scope(env);
+  Document* xdoc = Document::Unwrap(info.This().As<Napi::Object>());
+  if (!HasDocument(info, xdoc)) {
+    return env.Undefined();
+  }
+  std::string selector;
+  if (!GetStringArg(info, 0, "selector", &selector)) {
+    return env.Undefined();
+  }
+  XNode *root = (XNode*) xnode_document_root(xdoc->xdoc_wrapper_->xdoc);
+  Napi::Value value = Element::Query(env, xdoc->xdoc_wrapper_, root, selector.c_str());
+  if (!value.IsArray()) {
+    return env.Undefined();
+  }
+  Napi::Array array = value.As<Napi::Array>();
+  if (array.Length() == 1) {
+    return array.Get(uint32_t(0));
+  }
+  Napi::Error::New(env, "Not a single element").ThrowAsJavaScriptException();
+  return env.Undefined();
+}
+
+Napi::Value Document::FirstOrThrow(const Napi::CallbackInfo& info) {
+  return FirstSafe(info);
+}
+
+Napi::Value Document::OnlyOrThrow(const Napi::CallbackInfo& info) {
+  return OnlySafe(info);
+}
+
+Napi::Value Document::Text(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  Document* xdoc = Document::Unwrap(info.This().As<Napi::Object>());
+  if (!HasDocument(info, xdoc)) {
+    return env.Undefined();
+  }
+  std::string selector;
+  if (!GetStringArg(info, 0, "selector", &selector)) {
+    return env.Undefined();
+  }
+  XNode *root = (XNode*) xnode_document_root(xdoc->xdoc_wrapper_->xdoc);
+
+  QueryHandle query(selector.c_str());
+  if (!query.get()) {
+    Napi::Error::New(env, "Bad selector.").ThrowAsJavaScriptException();
+    return env.Undefined();
+  }
+
+  const XNodeArray *result = xnode_query_execute(query.get(), root);
+  if (result && xnode_array_size(result) > 0) {
+    XNode *node = xnode_array_get(result, 0);
+    std::string text;
+    if (info.Length() > 1 && info[1].IsObject()) {
+      Napi::Object opts = info[1].As<Napi::Object>();
+      if (opts.Has("separator") && opts.Get("separator").IsString()) {
+        std::string sep = opts.Get("separator").As<Napi::String>();
+        text = join_text_with_separator(node, sep);
+      } else {
+        text = get_inner_text(node);
+      }
+      if (opts.Has("normalize") && opts.Get("normalize").As<Napi::Boolean>()) {
+        text = normalize_whitespace(text);
+      }
+    } else {
+      text = get_inner_text(node);
+    }
+    return Napi::String::New(env, text);
+  }
+
+  return env.Null();
+}
+
+Napi::Value Document::TextOrThrow(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  Document* xdoc = Document::Unwrap(info.This().As<Napi::Object>());
+  if (!HasDocument(info, xdoc)) {
+    return env.Undefined();
+  }
+  std::string selector;
+  if (!GetStringArg(info, 0, "selector", &selector)) {
+    return env.Undefined();
+  }
+  XNode *root = (XNode*) xnode_document_root(xdoc->xdoc_wrapper_->xdoc);
+
+  QueryHandle query(selector.c_str());
+  if (!query.get()) {
+    Napi::Error::New(env, "Bad selector.").ThrowAsJavaScriptException();
+    return env.Undefined();
+  }
+
+  const XNodeArray *result = xnode_query_execute(query.get(), root);
+  if (result && xnode_array_size(result) > 0) {
+    XNode *node = xnode_array_get(result, 0);
+    return Napi::String::New(env, get_inner_text(node));
+  }
+
+  Napi::Error::New(env, "No element found").ThrowAsJavaScriptException();
+  return env.Undefined();
+}
+
+Napi::Value Document::Exists(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  Document* xdoc = Document::Unwrap(info.This().As<Napi::Object>());
+  if (!HasDocument(info, xdoc)) {
+    return env.Undefined();
+  }
+  std::string selector;
+  if (!GetStringArg(info, 0, "selector", &selector)) {
+    return env.Undefined();
+  }
+  XNode *root = (XNode*) xnode_document_root(xdoc->xdoc_wrapper_->xdoc);
+
+  QueryHandle query(selector.c_str());
+  if (!query.get()) {
+    Napi::Error::New(env, "Bad selector.").ThrowAsJavaScriptException();
+    return env.Undefined();
+  }
+
+  const XNodeArray *result = xnode_query_execute(query.get(), root);
+  return Napi::Boolean::New(env, result && xnode_array_size(result) > 0);
+}
+
+Napi::Value Document::Count(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  Document* xdoc = Document::Unwrap(info.This().As<Napi::Object>());
+  if (!HasDocument(info, xdoc)) {
+    return env.Undefined();
+  }
+  std::string selector;
+  if (!GetStringArg(info, 0, "selector", &selector)) {
+    return env.Undefined();
+  }
+  XNode *root = (XNode*) xnode_document_root(xdoc->xdoc_wrapper_->xdoc);
+
+  QueryHandle query(selector.c_str());
+  if (!query.get()) {
+    Napi::Error::New(env, "Bad selector.").ThrowAsJavaScriptException();
+    return env.Undefined();
+  }
+
+  const XNodeArray *result = xnode_query_execute(query.get(), root);
+  return Napi::Number::New(env, result ? xnode_array_size(result) : 0);
+}
+
+Napi::Value Document::Attr2(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  Document* xdoc = Document::Unwrap(info.This().As<Napi::Object>());
+  if (!HasDocument(info, xdoc)) {
+    return env.Undefined();
+  }
+  std::string selector;
+  if (!GetStringArg(info, 0, "selector", &selector)) {
+    return env.Undefined();
+  }
+  std::string attrName;
+  if (!GetStringArg(info, 1, "name", &attrName)) {
+    return env.Undefined();
+  }
+  XNode *root = (XNode*) xnode_document_root(xdoc->xdoc_wrapper_->xdoc);
+
+  QueryHandle query(selector.c_str());
+  if (!query.get()) {
+    Napi::Error::New(env, "Bad selector.").ThrowAsJavaScriptException();
+    return env.Undefined();
+  }
+
+  const XNodeArray *result = xnode_query_execute(query.get(), root);
+  if (result && xnode_array_size(result) > 0) {
+    XNode *node = xnode_array_get(result, 0);
+    const char *value = xnode_attr(node, attrName.c_str());
+    if (value) {
+      return Napi::String::New(env, value);
+    }
+  }
+
+  return env.Undefined();
+}
+
+Napi::Value Document::AttrOrThrow2(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  Document* xdoc = Document::Unwrap(info.This().As<Napi::Object>());
+  if (!HasDocument(info, xdoc)) {
+    return env.Undefined();
+  }
+  std::string selector;
+  if (!GetStringArg(info, 0, "selector", &selector)) {
+    return env.Undefined();
+  }
+  std::string attrName;
+  if (!GetStringArg(info, 1, "name", &attrName)) {
+    return env.Undefined();
+  }
+  XNode *root = (XNode*) xnode_document_root(xdoc->xdoc_wrapper_->xdoc);
+
+  QueryHandle query(selector.c_str());
+  if (!query.get()) {
+    Napi::Error::New(env, "Bad selector.").ThrowAsJavaScriptException();
+    return env.Undefined();
+  }
+
+  const XNodeArray *result = xnode_query_execute(query.get(), root);
+  if (result && xnode_array_size(result) > 0) {
+    XNode *node = xnode_array_get(result, 0);
+    const char *value = xnode_attr(node, attrName.c_str());
+    if (value) {
+      return Napi::String::New(env, value);
+    }
+  }
+
+  Napi::Error::New(env, "Attribute not found").ThrowAsJavaScriptException();
+  return env.Undefined();
+}
+
+Napi::Value Document::Parse(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  if (info.Length() == 0 || !info[0].IsString()) {
+    Napi::TypeError::New(env, "html must be a string")
+        .ThrowAsJavaScriptException();
+    return env.Undefined();
+  }
+  return Document::constructor.New({ info[0] });
+}
+
+} // namespace html