akamai_bookmarklet 0.1.0

data/vendor/gems/ruby/1.8/gems/nokogiri-1.3.3/ext/nokogiri/xml_schema.c

@@ -0,0 +1,156 @@
+#include <xml_schema.h>
+
+static void dealloc(xmlSchemaPtr schema)
+{
+  NOKOGIRI_DEBUG_START(schema);
+  xmlSchemaFree(schema);
+  NOKOGIRI_DEBUG_END(schema);
+}
+
+/*
+ * call-seq:
+ *  validate_document(document)
+ *
+ * Validate a Nokogiri::XML::Document against this Schema.
+ */
+static VALUE validate_document(VALUE self, VALUE document)
+{
+  xmlDocPtr doc;
+  xmlSchemaPtr schema;
+
+  Data_Get_Struct(self, xmlSchema, schema);
+  Data_Get_Struct(document, xmlDoc, doc);
+
+  VALUE errors = rb_ary_new();
+
+  xmlSchemaValidCtxtPtr valid_ctxt = xmlSchemaNewValidCtxt(schema);
+
+  if(NULL == valid_ctxt) {
+    // we have a problem
+    rb_raise(rb_eRuntimeError, "Could not create a validation context");
+  }
+
+#ifdef HAVE_XMLSCHEMASETVALIDSTRUCTUREDERRORS
+  xmlSchemaSetValidStructuredErrors(
+    valid_ctxt,
+    Nokogiri_error_array_pusher,
+    (void *)errors
+  );
+#endif
+
+  xmlSchemaValidateDoc(valid_ctxt, doc);
+
+  xmlSchemaFreeValidCtxt(valid_ctxt);
+
+  return errors;
+}
+
+/*
+ * call-seq:
+ *  read_memory(string)
+ *
+ * Create a new Schema from the contents of +string+
+ */
+static VALUE read_memory(VALUE klass, VALUE content)
+{
+
+  xmlSchemaParserCtxtPtr ctx = xmlSchemaNewMemParserCtxt(
+      (const char *)StringValuePtr(content),
+      RSTRING_LEN(content)
+  );
+
+  VALUE errors = rb_ary_new();
+  xmlSetStructuredErrorFunc((void *)errors, Nokogiri_error_array_pusher);
+
+#ifdef HAVE_XMLSCHEMASETPARSERSTRUCTUREDERRORS
+  xmlSchemaSetParserStructuredErrors(
+    ctx,
+    Nokogiri_error_array_pusher,
+    (void *)errors
+  );
+#endif
+
+  xmlSchemaPtr schema = xmlSchemaParse(ctx);
+
+  xmlSetStructuredErrorFunc(NULL, NULL);
+  xmlSchemaFreeParserCtxt(ctx);
+
+  if(NULL == schema) {
+    xmlErrorPtr error = xmlGetLastError();
+    if(error)
+      Nokogiri_error_raise(NULL, error);
+    else
+      rb_raise(rb_eRuntimeError, "Could not parse document");
+
+    return Qnil;
+  }
+
+  VALUE rb_schema = Data_Wrap_Struct(klass, 0, dealloc, schema);
+  rb_iv_set(rb_schema, "@errors", errors);
+
+  return rb_schema;
+}
+
+/*
+ * call-seq:
+ *  from_document(doc)
+ *
+ * Create a new Schema from the Nokogiri::XML::Document +doc+
+ */
+static VALUE from_document(VALUE klass, VALUE document)
+{
+  xmlDocPtr doc;
+  Data_Get_Struct(document, xmlDoc, doc);
+
+  // In case someone passes us a node. ugh.
+  doc = doc->doc;
+
+  xmlSchemaParserCtxtPtr ctx = xmlSchemaNewDocParserCtxt(doc);
+
+  VALUE errors = rb_ary_new();
+  xmlSetStructuredErrorFunc((void *)errors, Nokogiri_error_array_pusher);
+
+#ifdef HAVE_XMLSCHEMASETPARSERSTRUCTUREDERRORS
+  xmlSchemaSetParserStructuredErrors(
+    ctx,
+    Nokogiri_error_array_pusher,
+    (void *)errors
+  );
+#endif
+
+  xmlSchemaPtr schema = xmlSchemaParse(ctx);
+
+  xmlSetStructuredErrorFunc(NULL, NULL);
+  xmlSchemaFreeParserCtxt(ctx);
+
+  if(NULL == schema) {
+    xmlErrorPtr error = xmlGetLastError();
+    if(error)
+      Nokogiri_error_raise(NULL, error);
+    else
+      rb_raise(rb_eRuntimeError, "Could not parse document");
+
+    return Qnil;
+  }
+
+  VALUE rb_schema = Data_Wrap_Struct(klass, 0, dealloc, schema);
+  rb_iv_set(rb_schema, "@errors", errors);
+
+  return rb_schema;
+
+  return Qnil;
+}
+
+VALUE cNokogiriXmlSchema;
+void init_xml_schema()
+{
+  VALUE nokogiri = rb_define_module("Nokogiri");
+  VALUE xml = rb_define_module_under(nokogiri, "XML");
+  VALUE klass = rb_define_class_under(xml, "Schema", rb_cObject);
+
+  cNokogiriXmlSchema = klass;
+
+  rb_define_singleton_method(klass, "read_memory", read_memory, 1);
+  rb_define_singleton_method(klass, "from_document", from_document, 1);
+  rb_define_private_method(klass, "validate_document", validate_document, 1);
+}

data/vendor/gems/ruby/1.8/gems/nokogiri-1.3.3/ext/nokogiri/xml_schema.h

@@ -0,0 +1,9 @@
+#ifndef NOKOGIRI_XML_SCHEMA
+#define NOKOGIRI_XML_SCHEMA
+
+#include <nokogiri.h>
+
+void init_xml_schema();
+
+extern VALUE cNokogiriXmlSchema;
+#endif

data/vendor/gems/ruby/1.8/gems/nokogiri-1.3.3/ext/nokogiri/xml_syntax_error.c

@@ -0,0 +1,210 @@
+#include <xml_syntax_error.h>
+
+static void dealloc(xmlErrorPtr ptr)
+{
+  NOKOGIRI_DEBUG_START(ptr);
+  xmlResetError(ptr);
+  xmlFree(ptr);
+  NOKOGIRI_DEBUG_END(ptr);
+}
+
+/*
+ * call-seq:
+ *  column
+ *
+ * Column number or 0 if not available
+ */
+static VALUE column(VALUE self)
+{
+  xmlErrorPtr error;
+  Data_Get_Struct(self, xmlError, error);
+  return INT2NUM(error->int2);
+}
+
+/*
+ * call-seq:
+ *  int1
+ *
+ * Extra number information
+ */
+static VALUE int1(VALUE self)
+{
+  xmlErrorPtr error;
+  Data_Get_Struct(self, xmlError, error);
+  return INT2NUM(error->int1);
+}
+
+/*
+ * call-seq:
+ *  str3
+ *
+ * Extra string information
+ */
+static VALUE str3(VALUE self)
+{
+  xmlErrorPtr error;
+  Data_Get_Struct(self, xmlError, error);
+  if(error->str3)
+    return NOKOGIRI_STR_NEW2(error->str3, "UTF-8");
+  return Qnil;
+}
+
+/*
+ * call-seq:
+ *  str2
+ *
+ * Extra string information
+ */
+static VALUE str2(VALUE self)
+{
+  xmlErrorPtr error;
+  Data_Get_Struct(self, xmlError, error);
+  if(error->str2)
+    return NOKOGIRI_STR_NEW2(error->str2, "UTF-8");
+  return Qnil;
+}
+
+/*
+ * call-seq:
+ *  str1
+ *
+ * Extra string information
+ */
+static VALUE str1(VALUE self)
+{
+  xmlErrorPtr error;
+  Data_Get_Struct(self, xmlError, error);
+  if(error->str1)
+    return NOKOGIRI_STR_NEW2(error->str1, "UTF-8");
+  return Qnil;
+}
+
+/*
+ * call-seq:
+ *  line
+ *
+ * Get the line number of the error
+ */
+static VALUE line(VALUE self)
+{
+  xmlErrorPtr error;
+  Data_Get_Struct(self, xmlError, error);
+  return INT2NUM(error->line);
+}
+
+/*
+ * call-seq:
+ *  file
+ *
+ * Get the filename for the error
+ */
+static VALUE file(VALUE self)
+{
+  xmlErrorPtr error;
+  Data_Get_Struct(self, xmlError, error);
+  if(error->file)
+    return NOKOGIRI_STR_NEW2(error->file, "UTF-8");
+
+  return Qnil;
+}
+
+/*
+ * call-seq:
+ *  level
+ *
+ * Get the error level
+ */
+static VALUE level(VALUE self)
+{
+  xmlErrorPtr error;
+  Data_Get_Struct(self, xmlError, error);
+  return INT2NUM((short)error->level);
+}
+
+/*
+ * call-seq:
+ *  code
+ *
+ * Get the error code
+ */
+static VALUE code(VALUE self)
+{
+  xmlErrorPtr error;
+  Data_Get_Struct(self, xmlError, error);
+  return INT2NUM(error->code);
+}
+
+/*
+ * call-seq:
+ *  domain
+ *
+ * Get the part of the library that raised this exception
+ */
+static VALUE domain(VALUE self)
+{
+  xmlErrorPtr error;
+  Data_Get_Struct(self, xmlError, error);
+  return INT2NUM(error->domain);
+}
+
+/*
+ * call-seq:
+ *  message
+ *
+ * Get the human readable message.
+ */
+static VALUE message(VALUE self)
+{
+  xmlErrorPtr error;
+  Data_Get_Struct(self, xmlError, error);
+  return NOKOGIRI_STR_NEW2(error->message, "UTF-8");
+}
+
+void Nokogiri_error_array_pusher(void * ctx, xmlErrorPtr error)
+{
+  VALUE list = (VALUE)ctx;
+  rb_ary_push(list,  Nokogiri_wrap_xml_syntax_error((VALUE)NULL, error));
+}
+
+void Nokogiri_error_raise(void * ctx, xmlErrorPtr error)
+{
+  rb_funcall(rb_mKernel, rb_intern("raise"), 1,
+      Nokogiri_wrap_xml_syntax_error((VALUE)NULL, error)
+  );
+}
+
+VALUE Nokogiri_wrap_xml_syntax_error(VALUE klass, xmlErrorPtr error)
+{
+  if(!klass) klass = cNokogiriXmlSyntaxError;
+
+  xmlErrorPtr ptr = calloc(1, sizeof(xmlError));
+  xmlCopyError(error, ptr);
+
+  return Data_Wrap_Struct(klass, NULL, dealloc, ptr);
+}
+
+VALUE cNokogiriXmlSyntaxError;
+void init_xml_syntax_error()
+{
+  VALUE nokogiri = rb_define_module("Nokogiri");
+  VALUE xml = rb_define_module_under(nokogiri, "XML");
+
+  /*
+   * The XML::SyntaxError is raised on parse errors
+   */
+  VALUE syntax_error_mommy = rb_define_class_under(nokogiri, "SyntaxError", rb_eStandardError);
+  VALUE klass = rb_define_class_under(xml, "SyntaxError", syntax_error_mommy);
+  cNokogiriXmlSyntaxError = klass;
+
+  rb_define_method(klass, "message", message, 0);
+  rb_define_method(klass, "domain", domain, 0);
+  rb_define_method(klass, "code", code, 0);
+  rb_define_method(klass, "level", level, 0);
+  rb_define_method(klass, "file", file, 0);
+  rb_define_method(klass, "line", line, 0);
+  rb_define_method(klass, "str1", str1, 0);
+  rb_define_method(klass, "str2", str2, 0);
+  rb_define_method(klass, "str3", str3, 0);
+  rb_define_method(klass, "int1", int1, 0);
+  rb_define_method(klass, "column", column, 0);
+}

data/vendor/gems/ruby/1.8/gems/nokogiri-1.3.3/ext/nokogiri/xml_syntax_error.h

@@ -0,0 +1,13 @@
+#ifndef NOKOGIRI_XML_SYNTAX_ERROR
+#define NOKOGIRI_XML_SYNTAX_ERROR
+
+#include <nokogiri.h>
+
+void init_xml_syntax_error();
+VALUE Nokogiri_wrap_xml_syntax_error(VALUE klass, xmlErrorPtr error);
+void Nokogiri_error_array_pusher(void * ctx, xmlErrorPtr error);
+void Nokogiri_error_raise(void * ctx, xmlErrorPtr error);
+
+extern VALUE cNokogiriXmlSyntaxError;
+#endif
+

data/vendor/gems/ruby/1.8/gems/nokogiri-1.3.3/ext/nokogiri/xml_text.c

@@ -0,0 +1,47 @@
+#include <xml_text.h>
+
+/*
+ * call-seq:
+ *  new(content, document)
+ *
+ * Create a new Text element on the +document+ with +content+
+ */
+static VALUE new(int argc, VALUE *argv, VALUE klass)
+{
+  xmlDocPtr doc;
+  VALUE string;
+  VALUE document;
+  VALUE rest;
+
+  rb_scan_args(argc, argv, "2*", &string, &document, &rest);
+
+  Data_Get_Struct(document, xmlDoc, doc);
+
+  xmlNodePtr node = xmlNewText((xmlChar *)StringValuePtr(string));
+  node->doc = doc;
+
+  VALUE rb_node = Nokogiri_wrap_xml_node(klass, node) ;
+  rb_funcall2(rb_node, rb_intern("initialize"), argc, argv);
+
+  if(rb_block_given_p()) rb_yield(rb_node);
+
+  return rb_node;
+}
+
+VALUE cNokogiriXmlText ;
+void init_xml_text()
+{
+  VALUE nokogiri = rb_define_module("Nokogiri");
+  VALUE xml = rb_define_module_under(nokogiri, "XML");
+  /* */
+  VALUE node = rb_define_class_under(xml, "Node", rb_cObject);
+
+  /*
+   * Wraps Text nodes.
+   */
+  VALUE klass = rb_define_class_under(xml, "Text", node);
+
+  cNokogiriXmlText = klass;
+
+  rb_define_singleton_method(klass, "new", new, -1);
+}

data/vendor/gems/ruby/1.8/gems/nokogiri-1.3.3/ext/nokogiri/xml_text.h

@@ -0,0 +1,9 @@
+#ifndef NOKOGIRI_XML_TEXT
+#define NOKOGIRI_XML_TEXT
+
+#include <nokogiri.h>
+
+void init_xml_text();
+
+extern VALUE cNokogiriXmlText ;
+#endif

data/vendor/gems/ruby/1.8/gems/nokogiri-1.3.3/ext/nokogiri/xml_xpath.c

@@ -0,0 +1,53 @@
+#include <xml_xpath.h>
+
+static void deallocate(xmlXPathObjectPtr xpath)
+{
+  NOKOGIRI_DEBUG_START(xpath);
+  xmlXPathFreeNodeSetList(xpath); // despite the name, this frees the xpath but not the contained node set
+  NOKOGIRI_DEBUG_END(xpath);
+}
+
+VALUE Nokogiri_wrap_xml_xpath(xmlXPathObjectPtr xpath)
+{
+  return Data_Wrap_Struct(cNokogiriXmlXpath, 0, deallocate, xpath);
+}
+
+/*
+ * call-seq:
+ *  node_set
+ *
+ * Fetch the node set associated with this xpath context.
+ */
+static VALUE node_set(VALUE self)
+{
+  xmlXPathObjectPtr xpath;
+  Data_Get_Struct(self, xmlXPathObject, xpath);
+
+  VALUE node_set = Qnil;
+
+  if (xpath->nodesetval)
+    node_set = Nokogiri_wrap_xml_node_set(xpath->nodesetval);
+
+  if(Qnil == node_set)
+    node_set = Nokogiri_wrap_xml_node_set(xmlXPathNodeSetCreate(NULL));
+
+  rb_funcall(node_set, rb_intern("document="), 1, rb_iv_get(self, "@document"));
+
+  return node_set;
+}
+
+VALUE cNokogiriXmlXpath;
+void init_xml_xpath(void)
+{
+  VALUE module = rb_define_module("Nokogiri");
+  VALUE xml = rb_define_module_under(module, "XML");
+
+  /*
+   * This class wraps an XPath object and should only be instantiated from
+   * XPathContext.
+   */
+  VALUE klass = rb_define_class_under(xml, "XPath", rb_cObject);
+
+  cNokogiriXmlXpath = klass;
+  rb_define_method(klass, "node_set", node_set, 0);
+}

data/vendor/gems/ruby/1.8/gems/nokogiri-1.3.3/ext/nokogiri/xml_xpath.h

@@ -0,0 +1,11 @@
+#ifndef NOKOGIRI_XML_XPATH
+#define NOKOGIRI_XML_XPATH
+
+#include <nokogiri.h>
+
+void init_xml_xpath();
+VALUE Nokogiri_wrap_xml_xpath(xmlXPathObjectPtr xpath);
+
+extern VALUE cNokogiriXmlXpath;
+#endif
+