domo 0.0.3 → 0.0.4

data/vendor/bundle/ruby/1.9.1/gems/nokogiri-1.4.4/ext/nokogiri/xml_element_decl.h

@@ -0,0 +1,9 @@
+#ifndef NOKOGIRI_XML_ELEMENT_DECL
+#define NOKOGIRI_XML_ELEMENT_DECL
+
+#include <nokogiri.h>
+
+void init_xml_element_decl();
+
+extern VALUE cNokogiriXmlElementDecl;
+#endif

data/vendor/bundle/ruby/1.9.1/gems/nokogiri-1.4.4/ext/nokogiri/xml_encoding_handler.c

@@ -0,0 +1,79 @@
+#include <xml_encoding_handler.h>
+
+/*
+ * call-seq: Nokogiri::EncodingHandler.[](name)
+ *
+ * Get the encoding handler for +name+
+ */
+static VALUE get(VALUE klass, VALUE key)
+{
+  xmlCharEncodingHandlerPtr handler;
+
+  handler = xmlFindCharEncodingHandler(StringValuePtr(key));
+  if(handler)
+    return Data_Wrap_Struct(klass, NULL, NULL, handler);
+
+  return Qnil;
+}
+
+/*
+ * call-seq: Nokogiri::EncodingHandler.delete(name)
+ *
+ * Delete the encoding alias named +name+
+ */
+static VALUE delete(VALUE klass, VALUE name)
+{
+  if(xmlDelEncodingAlias(StringValuePtr(name))) return Qnil;
+
+  return Qtrue;
+}
+
+/*
+ * call-seq: Nokogiri::EncodingHandler.alias(from, to)
+ *
+ * Alias encoding handler with name +from+ to name +to+
+ */
+static VALUE alias(VALUE klass, VALUE from, VALUE to)
+{
+  xmlAddEncodingAlias(StringValuePtr(from), StringValuePtr(to));
+
+  return to;
+}
+
+/*
+ * call-seq: Nokogiri::EncodingHandler.clear_aliases!
+ *
+ * Remove all encoding aliases.
+ */
+static VALUE clear_aliases(VALUE klass)
+{
+  xmlCleanupEncodingAliases();
+
+  return klass;
+}
+
+/*
+ * call-seq: name
+ *
+ * Get the name of this EncodingHandler
+ */
+static VALUE name(VALUE self)
+{
+  xmlCharEncodingHandlerPtr handler;
+
+  Data_Get_Struct(self, xmlCharEncodingHandler, handler);
+
+  return NOKOGIRI_STR_NEW2(handler->name);
+}
+
+void init_xml_encoding_handler()
+{
+  VALUE nokogiri = rb_define_module("Nokogiri");
+  VALUE klass = rb_define_class_under(nokogiri, "EncodingHandler", rb_cObject);
+
+  rb_define_singleton_method(klass, "[]", get, 1);
+  rb_define_singleton_method(klass, "delete", delete, 1);
+  rb_define_singleton_method(klass, "alias", alias, 2);
+  rb_define_singleton_method(klass, "clear_aliases!", clear_aliases, 0);
+  rb_define_method(klass, "name", name, 0);
+}

data/vendor/bundle/ruby/1.9.1/gems/nokogiri-1.4.4/ext/nokogiri/xml_encoding_handler.h

@@ -0,0 +1,8 @@
+#ifndef NOKOGIRI_XML_ENCODING_HANDLER
+#define NOKOGIRI_XML_ENCODING_HANDLER
+
+#include <nokogiri.h>
+
+void init_xml_encoding_handler();
+
+#endif

data/vendor/bundle/ruby/1.9.1/gems/nokogiri-1.4.4/ext/nokogiri/xml_entity_decl.c

@@ -0,0 +1,110 @@
+#include <xml_entity_decl.h>
+
+/*
+ * call-seq:
+ *  original_content
+ *
+ * Get the original_content before ref substitution
+ */
+static VALUE original_content(VALUE self)
+{
+  xmlEntityPtr node;
+  Data_Get_Struct(self, xmlEntity, node);
+
+  if(!node->orig) return Qnil;
+
+  return NOKOGIRI_STR_NEW2(node->orig);
+}
+
+/*
+ * call-seq:
+ *  content
+ *
+ * Get the content
+ */
+static VALUE get_content(VALUE self)
+{
+  xmlEntityPtr node;
+  Data_Get_Struct(self, xmlEntity, node);
+
+  if(!node->content) return Qnil;
+
+  return NOKOGIRI_STR_NEW(node->content, node->length);
+}
+
+/*
+ * call-seq:
+ *  entity_type
+ *
+ * Get the entity type
+ */
+static VALUE entity_type(VALUE self)
+{
+  xmlEntityPtr node;
+  Data_Get_Struct(self, xmlEntity, node);
+
+  return INT2NUM((int)node->etype);
+}
+
+/*
+ * call-seq:
+ *  external_id
+ *
+ * Get the external identifier for PUBLIC
+ */
+static VALUE external_id(VALUE self)
+{
+  xmlEntityPtr node;
+  Data_Get_Struct(self, xmlEntity, node);
+
+  if(!node->ExternalID) return Qnil;
+
+  return NOKOGIRI_STR_NEW2(node->ExternalID);
+}
+
+/*
+ * call-seq:
+ *  system_id
+ *
+ * Get the URI for a SYSTEM or PUBLIC Entity
+ */
+static VALUE system_id(VALUE self)
+{
+  xmlEntityPtr node;
+  Data_Get_Struct(self, xmlEntity, node);
+
+  if(!node->SystemID) return Qnil;
+
+  return NOKOGIRI_STR_NEW2(node->SystemID);
+}
+
+VALUE cNokogiriXmlEntityDecl;
+
+void init_xml_entity_decl()
+{
+  VALUE nokogiri = rb_define_module("Nokogiri");
+  VALUE xml = rb_define_module_under(nokogiri, "XML");
+  VALUE node = rb_define_class_under(xml, "Node", rb_cObject);
+  VALUE klass = rb_define_class_under(xml, "EntityDecl", node);
+
+  cNokogiriXmlEntityDecl = klass;
+
+  rb_define_method(klass, "original_content", original_content, 0);
+  rb_define_method(klass, "content", get_content, 0);
+  rb_define_method(klass, "entity_type", entity_type, 0);
+  rb_define_method(klass, "external_id", external_id, 0);
+  rb_define_method(klass, "system_id", system_id, 0);
+
+  rb_const_set(cNokogiriXmlEntityDecl, rb_intern("INTERNAL_GENERAL"),
+      INT2NUM(XML_INTERNAL_GENERAL_ENTITY));
+  rb_const_set(cNokogiriXmlEntityDecl, rb_intern("EXTERNAL_GENERAL_PARSED"),
+      INT2NUM(XML_EXTERNAL_GENERAL_PARSED_ENTITY));
+  rb_const_set(cNokogiriXmlEntityDecl, rb_intern("EXTERNAL_GENERAL_UNPARSED"),
+      INT2NUM(XML_EXTERNAL_GENERAL_UNPARSED_ENTITY));
+  rb_const_set(cNokogiriXmlEntityDecl, rb_intern("INTERNAL_PARAMETER"),
+      INT2NUM(XML_INTERNAL_PARAMETER_ENTITY));
+  rb_const_set(cNokogiriXmlEntityDecl, rb_intern("EXTERNAL_PARAMETER"),
+      INT2NUM(XML_EXTERNAL_PARAMETER_ENTITY));
+  rb_const_set(cNokogiriXmlEntityDecl, rb_intern("INTERNAL_PREDEFINED"),
+      INT2NUM(XML_INTERNAL_PREDEFINED_ENTITY));
+}

data/vendor/bundle/ruby/1.9.1/gems/nokogiri-1.4.4/ext/nokogiri/xml_entity_decl.h

@@ -0,0 +1,10 @@
+#ifndef NOKOGIRI_XML_ENTITY_DECL
+#define NOKOGIRI_XML_ENTITY_DECL
+
+#include <nokogiri.h>
+
+void init_xml_entity_decl();
+
+extern VALUE cNokogiriXmlEntityDecl;
+#endif
+

data/vendor/bundle/ruby/1.9.1/gems/nokogiri-1.4.4/ext/nokogiri/xml_entity_reference.c

@@ -0,0 +1,52 @@
+#include <xml_entity_reference.h>
+
+/*
+ * call-seq:
+ *  new(document, content)
+ *
+ * Create a new EntityReference element on the +document+ with +name+
+ */
+static VALUE new(int argc, VALUE *argv, VALUE klass)
+{
+  xmlDocPtr xml_doc;
+  xmlNodePtr node;
+  VALUE document;
+  VALUE name;
+  VALUE rest;
+  VALUE rb_node;
+
+  rb_scan_args(argc, argv, "2*", &document, &name, &rest);
+
+  Data_Get_Struct(document, xmlDoc, xml_doc);
+
+  node = xmlNewReference(
+      xml_doc,
+      (const xmlChar *)StringValuePtr(name)
+  );
+
+  NOKOGIRI_ROOT_NODE(node);
+
+  rb_node = Nokogiri_wrap_xml_node(klass, node);
+  rb_obj_call_init(rb_node, argc, argv);
+
+  if(rb_block_given_p()) rb_yield(rb_node);
+
+  return rb_node;
+}
+
+VALUE cNokogiriXmlEntityReference;
+void init_xml_entity_reference()
+{
+  VALUE nokogiri = rb_define_module("Nokogiri");
+  VALUE xml = rb_define_module_under(nokogiri, "XML");
+  VALUE node = rb_define_class_under(xml, "Node", rb_cObject);
+
+  /*
+   * EntityReference represents an EntityReference node in an xml document.
+   */
+  VALUE klass = rb_define_class_under(xml, "EntityReference", node);
+
+  cNokogiriXmlEntityReference = klass;
+
+  rb_define_singleton_method(klass, "new", new, -1);
+}

data/vendor/bundle/ruby/1.9.1/gems/nokogiri-1.4.4/ext/nokogiri/xml_entity_reference.h

@@ -0,0 +1,9 @@
+#ifndef NOKOGIRI_XML_ENTITY_REFERENCE
+#define NOKOGIRI_XML_ENTITY_REFERENCE
+
+#include <nokogiri.h>
+
+void init_xml_entity_reference();
+
+extern VALUE cNokogiriXmlEntityReference;
+#endif

data/vendor/bundle/ruby/1.9.1/gems/nokogiri-1.4.4/ext/nokogiri/xml_io.c

@@ -0,0 +1,31 @@
+#include <xml_io.h>
+
+static ID id_read, id_write;
+
+int io_read_callback(void * ctx, char * buffer, int len) {
+  VALUE io = (VALUE)ctx;
+  VALUE string = rb_funcall(io, id_read, 1, INT2NUM(len));
+
+  if(NIL_P(string)) return 0;
+
+  memcpy(buffer, StringValuePtr(string), (size_t)RSTRING_LEN(string));
+
+  return (int)RSTRING_LEN(string);
+}
+
+int io_write_callback(void * ctx, char * buffer, int len) {
+  VALUE io = (VALUE)ctx;
+  VALUE string = rb_str_new(buffer, (long)len);
+
+  rb_funcall(io, id_write, 1, string);
+  return len;
+}
+
+int io_close_callback(void * ctx) {
+  return 0;
+}
+
+void init_nokogiri_io() {
+  id_read = rb_intern("read");
+  id_write = rb_intern("write");
+}

data/vendor/bundle/ruby/1.9.1/gems/nokogiri-1.4.4/ext/nokogiri/xml_io.h

@@ -0,0 +1,11 @@
+#ifndef NOKOGIRI_XML_IO
+#define NOKOGIRI_XML_IO
+
+#include <nokogiri.h>
+
+int io_read_callback(void * ctx, char * buffer, int len);
+int io_write_callback(void * ctx, char * buffer, int len);
+int io_close_callback(void * ctx);
+void init_nokogiri_io();
+
+#endif

data/vendor/bundle/ruby/1.9.1/gems/nokogiri-1.4.4/ext/nokogiri/xml_libxml2_hacks.c

@@ -0,0 +1,112 @@
+#ifndef HAVE_XMLFIRSTELEMENTCHILD
+#include <libxml/tree.h>
+/**
+ * xmlFirstElementChild:
+ * @parent: the parent node
+ *
+ * Finds the first child node of that element which is a Element node
+ * Note the handling of entities references is different than in
+ * the W3C DOM element traversal spec since we don't have back reference
+ * from entities content to entities references.
+ *
+ * Returns the first element child or NULL if not available
+ */
+xmlNodePtr
+xmlFirstElementChild(xmlNodePtr parent) {
+    xmlNodePtr cur = NULL;
+
+    if (parent == NULL)
+        return(NULL);
+    switch (parent->type) {
+        case XML_ELEMENT_NODE:
+        case XML_ENTITY_NODE:
+        case XML_DOCUMENT_NODE:
+        case XML_HTML_DOCUMENT_NODE:
+            cur = parent->children;
+            break;
+        default:
+            return(NULL);
+    }
+    while (cur != NULL) {
+        if (cur->type == XML_ELEMENT_NODE)
+            return(cur);
+        cur = cur->next;
+    }
+    return(NULL);
+}
+
+/**
+ * xmlNextElementSibling:
+ * @node: the current node
+ *
+ * Finds the first closest next sibling of the node which is an
+ * element node.
+ * Note the handling of entities references is different than in
+ * the W3C DOM element traversal spec since we don't have back reference
+ * from entities content to entities references.
+ *
+ * Returns the next element sibling or NULL if not available
+ */
+xmlNodePtr
+xmlNextElementSibling(xmlNodePtr node) {
+    if (node == NULL)
+        return(NULL);
+    switch (node->type) {
+        case XML_ELEMENT_NODE:
+        case XML_TEXT_NODE:
+        case XML_CDATA_SECTION_NODE:
+        case XML_ENTITY_REF_NODE:
+        case XML_ENTITY_NODE:
+        case XML_PI_NODE:
+        case XML_COMMENT_NODE:
+        case XML_DTD_NODE:
+        case XML_XINCLUDE_START:
+        case XML_XINCLUDE_END:
+            node = node->next;
+            break;
+        default:
+            return(NULL);
+    }
+    while (node != NULL) {
+        if (node->type == XML_ELEMENT_NODE)
+            return(node);
+        node = node->next;
+    }
+    return(NULL);
+}
+
+/**
+ * xmlLastElementChild:
+ * @parent: the parent node
+ *
+ * Finds the last child node of that element which is a Element node
+ * Note the handling of entities references is different than in
+ * the W3C DOM element traversal spec since we don't have back reference
+ * from entities content to entities references.
+ *
+ * Returns the last element child or NULL if not available
+ */
+xmlNodePtr
+xmlLastElementChild(xmlNodePtr parent) {
+    xmlNodePtr cur = NULL;
+
+    if (parent == NULL)
+        return(NULL);
+    switch (parent->type) {
+        case XML_ELEMENT_NODE:
+        case XML_ENTITY_NODE:
+        case XML_DOCUMENT_NODE:
+        case XML_HTML_DOCUMENT_NODE:
+            cur = parent->last;
+            break;
+        default:
+            return(NULL);
+    }
+    while (cur != NULL) {
+        if (cur->type == XML_ELEMENT_NODE)
+            return(cur);
+        cur = cur->prev;
+    }
+    return(NULL);
+}
+#endif