horseman 0.0.1 → 0.0.2

data/vendor/ruby/1.9.1/gems/nokogiri-1.5.0/ext/nokogiri/html_element_description.c

@@ -0,0 +1,276 @@
+#include <html_element_description.h>
+
+/*
+ * call-seq:
+ *  required_attributes
+ *
+ * A list of required attributes for this element
+ */
+static VALUE required_attributes(VALUE self)
+{
+  htmlElemDesc * description;
+  VALUE list;
+  int i;
+
+  Data_Get_Struct(self, htmlElemDesc, description);
+
+  list = rb_ary_new();
+
+  if(NULL == description->attrs_req) return list;
+
+  for(i = 0; description->attrs_depr[i]; i++) {
+    rb_ary_push(list, NOKOGIRI_STR_NEW2(description->attrs_req[i]));
+  }
+
+  return list;
+}
+
+/*
+ * call-seq:
+ *  deprecated_attributes
+ *
+ * A list of deprecated attributes for this element
+ */
+static VALUE deprecated_attributes(VALUE self)
+{
+  htmlElemDesc * description;
+  VALUE list;
+  int i;
+
+  Data_Get_Struct(self, htmlElemDesc, description);
+
+  list = rb_ary_new();
+
+  if(NULL == description->attrs_depr) return list;
+
+  for(i = 0; description->attrs_depr[i]; i++) {
+    rb_ary_push(list, NOKOGIRI_STR_NEW2(description->attrs_depr[i]));
+  }
+
+  return list;
+}
+
+/*
+ * call-seq:
+ *  optional_attributes
+ *
+ * A list of optional attributes for this element
+ */
+static VALUE optional_attributes(VALUE self)
+{
+  htmlElemDesc * description;
+  VALUE list;
+  int i;
+
+  Data_Get_Struct(self, htmlElemDesc, description);
+
+  list = rb_ary_new();
+
+  if(NULL == description->attrs_opt) return list;
+
+  for(i = 0; description->attrs_opt[i]; i++) {
+    rb_ary_push(list, NOKOGIRI_STR_NEW2(description->attrs_opt[i]));
+  }
+
+  return list;
+}
+
+/*
+ * call-seq:
+ *  default_sub_element
+ *
+ * The default sub element for this element
+ */
+static VALUE default_sub_element(VALUE self)
+{
+  htmlElemDesc * description;
+  Data_Get_Struct(self, htmlElemDesc, description);
+
+  return NOKOGIRI_STR_NEW2(description->defaultsubelt);
+}
+
+/*
+ * call-seq:
+ *  sub_elements
+ *
+ * A list of allowed sub elements for this element.
+ */
+static VALUE sub_elements(VALUE self)
+{
+  htmlElemDesc * description;
+  VALUE list;
+  int i;
+
+  Data_Get_Struct(self, htmlElemDesc, description);
+
+  list = rb_ary_new();
+
+  if(NULL == description->subelts) return list;
+
+  for(i = 0; description->subelts[i]; i++) {
+    rb_ary_push(list, NOKOGIRI_STR_NEW2(description->subelts[i]));
+  }
+
+  return list;
+}
+
+/*
+ * call-seq:
+ *  description
+ *
+ * The description for this element
+ */
+static VALUE description(VALUE self)
+{
+  htmlElemDesc * description;
+  Data_Get_Struct(self, htmlElemDesc, description);
+
+  return NOKOGIRI_STR_NEW2(description->desc);
+}
+
+/*
+ * call-seq:
+ *  inline?
+ *
+ * Is this element an inline element?
+ */
+static VALUE inline_eh(VALUE self)
+{
+  htmlElemDesc * description;
+  Data_Get_Struct(self, htmlElemDesc, description);
+
+  if(description->isinline) return Qtrue;
+  return Qfalse;
+}
+
+/*
+ * call-seq:
+ *  deprecated?
+ *
+ * Is this element deprecated?
+ */
+static VALUE deprecated_eh(VALUE self)
+{
+  htmlElemDesc * description;
+  Data_Get_Struct(self, htmlElemDesc, description);
+
+  if(description->depr) return Qtrue;
+  return Qfalse;
+}
+
+/*
+ * call-seq:
+ *  empty?
+ *
+ * Is this an empty element?
+ */
+static VALUE empty_eh(VALUE self)
+{
+  htmlElemDesc * description;
+  Data_Get_Struct(self, htmlElemDesc, description);
+
+  if(description->empty) return Qtrue;
+  return Qfalse;
+}
+
+/*
+ * call-seq:
+ *  save_end_tag?
+ *
+ * Should the end tag be saved?
+ */
+static VALUE save_end_tag_eh(VALUE self)
+{
+  htmlElemDesc * description;
+  Data_Get_Struct(self, htmlElemDesc, description);
+
+  if(description->saveEndTag) return Qtrue;
+  return Qfalse;
+}
+
+/*
+ * call-seq:
+ *  implied_end_tag?
+ *
+ * Can the end tag be implied for this tag?
+ */
+static VALUE implied_end_tag_eh(VALUE self)
+{
+  htmlElemDesc * description;
+  Data_Get_Struct(self, htmlElemDesc, description);
+
+  if(description->endTag) return Qtrue;
+  return Qfalse;
+}
+
+/*
+ * call-seq:
+ *  implied_start_tag?
+ *
+ * Can the start tag be implied for this tag?
+ */
+static VALUE implied_start_tag_eh(VALUE self)
+{
+  htmlElemDesc * description;
+  Data_Get_Struct(self, htmlElemDesc, description);
+
+  if(description->startTag) return Qtrue;
+  return Qfalse;
+}
+
+/*
+ * call-seq:
+ *  name
+ *
+ * Get the tag name for this ElemementDescription
+ */
+static VALUE name(VALUE self)
+{
+  htmlElemDesc * description;
+  Data_Get_Struct(self, htmlElemDesc, description);
+
+  if(NULL == description->name) return Qnil;
+  return NOKOGIRI_STR_NEW2(description->name);
+}
+
+/*
+ * call-seq:
+ *  [](tag_name)
+ *
+ * Get ElemementDescription for +tag_name+
+ */
+static VALUE get_description(VALUE klass, VALUE tag_name)
+{
+  const htmlElemDesc * description = htmlTagLookup(
+      (const xmlChar *)StringValuePtr(tag_name)
+  );
+
+  if(NULL == description) return Qnil;
+  return Data_Wrap_Struct(klass, 0, 0, (void *)description);
+}
+
+VALUE cNokogiriHtmlElementDescription ;
+void init_html_element_description()
+{
+  VALUE nokogiri = rb_define_module("Nokogiri");
+  VALUE html     = rb_define_module_under(nokogiri, "HTML");
+  VALUE klass    = rb_define_class_under(html, "ElementDescription",rb_cObject);
+
+  cNokogiriHtmlElementDescription = klass;
+
+  rb_define_singleton_method(klass, "[]", get_description, 1);
+
+  rb_define_method(klass, "name", name, 0);
+  rb_define_method(klass, "implied_start_tag?", implied_start_tag_eh, 0);
+  rb_define_method(klass, "implied_end_tag?", implied_end_tag_eh, 0);
+  rb_define_method(klass, "save_end_tag?", save_end_tag_eh, 0);
+  rb_define_method(klass, "empty?", empty_eh, 0);
+  rb_define_method(klass, "deprecated?", deprecated_eh, 0);
+  rb_define_method(klass, "inline?", inline_eh, 0);
+  rb_define_method(klass, "description", description, 0);
+  rb_define_method(klass, "sub_elements", sub_elements, 0);
+  rb_define_method(klass, "default_sub_element", default_sub_element, 0);
+  rb_define_method(klass, "optional_attributes", optional_attributes, 0);
+  rb_define_method(klass, "deprecated_attributes", deprecated_attributes, 0);
+  rb_define_method(klass, "required_attributes", required_attributes, 0);
+}

data/vendor/ruby/1.9.1/gems/nokogiri-1.5.0/ext/nokogiri/html_element_description.h

@@ -0,0 +1,10 @@
+#ifndef NOKOGIRI_HTML_ELEMENT_DESCRIPTION
+#define NOKOGIRI_HTML_ELEMENT_DESCRIPTION
+
+#include <nokogiri.h>
+
+void init_html_element_description();
+
+extern VALUE cNokogiriHtmlElementDescription ;
+
+#endif

data/vendor/ruby/1.9.1/gems/nokogiri-1.5.0/ext/nokogiri/html_entity_lookup.c

@@ -0,0 +1,32 @@
+#include <html_entity_lookup.h>
+
+/*
+ * call-seq:
+ *  get(key)
+ *
+ * Get the HTML::EntityDescription for +key+
+ */
+static VALUE get(VALUE self, VALUE key)
+{
+  const htmlEntityDesc * desc =
+    htmlEntityLookup((const xmlChar *)StringValuePtr(key));
+  VALUE klass, args[3];
+
+  if(NULL == desc) return Qnil;
+  klass = rb_const_get(mNokogiriHtml, rb_intern("EntityDescription"));
+
+  args[0] = INT2NUM((long)desc->value);
+  args[1] = NOKOGIRI_STR_NEW2(desc->name);
+  args[2] = NOKOGIRI_STR_NEW2(desc->desc);
+
+  return rb_class_new_instance(3, args, klass);
+}
+
+void init_html_entity_lookup()
+{
+  VALUE nokogiri = rb_define_module("Nokogiri");
+  VALUE html = rb_define_module_under(nokogiri, "HTML");
+  VALUE klass = rb_define_class_under(html, "EntityLookup", rb_cObject);
+
+  rb_define_method(klass, "get", get, 1);
+}

data/vendor/ruby/1.9.1/gems/nokogiri-1.5.0/ext/nokogiri/html_entity_lookup.h

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

data/vendor/ruby/1.9.1/gems/nokogiri-1.5.0/ext/nokogiri/html_sax_parser_context.c

@@ -0,0 +1,94 @@
+#include <html_sax_parser_context.h>
+
+VALUE cNokogiriHtmlSaxParserContext ;
+
+static void deallocate(xmlParserCtxtPtr ctxt)
+{
+  NOKOGIRI_DEBUG_START(handler);
+
+  ctxt->sax = NULL;
+
+  htmlFreeParserCtxt(ctxt);
+
+  NOKOGIRI_DEBUG_END(handler);
+}
+
+static VALUE parse_memory(VALUE klass, VALUE data, VALUE encoding)
+{
+  htmlParserCtxtPtr ctxt;
+
+  if(NIL_P(data)) rb_raise(rb_eArgError, "data cannot be nil");
+  if(!(int)RSTRING_LEN(data))
+    rb_raise(rb_eRuntimeError, "data cannot be empty");
+
+  ctxt = htmlCreateMemoryParserCtxt(
+      StringValuePtr(data),
+      (int)RSTRING_LEN(data)
+  );
+
+  if(RTEST(encoding)) {
+    xmlCharEncodingHandlerPtr enc = xmlFindCharEncodingHandler(StringValuePtr(encoding));
+    if(enc != NULL) {
+      xmlSwitchToEncoding(ctxt, enc);
+      if(ctxt->errNo == XML_ERR_UNSUPPORTED_ENCODING) {
+        rb_raise(rb_eRuntimeError, "Unsupported encoding %s",
+            StringValuePtr(encoding));
+      }
+    }
+  }
+
+  return Data_Wrap_Struct(klass, NULL, deallocate, ctxt);
+}
+
+static VALUE parse_file(VALUE klass, VALUE filename, VALUE encoding)
+{
+  htmlParserCtxtPtr ctxt = htmlCreateFileParserCtxt(
+      StringValuePtr(filename),
+      StringValuePtr(encoding)
+  );
+  return Data_Wrap_Struct(klass, NULL, deallocate, ctxt);
+}
+
+static VALUE parse_with(VALUE self, VALUE sax_handler)
+{
+  htmlParserCtxtPtr ctxt;
+  htmlSAXHandlerPtr sax;
+
+  if(!rb_obj_is_kind_of(sax_handler, cNokogiriXmlSaxParser))
+    rb_raise(rb_eArgError, "argument must be a Nokogiri::XML::SAX::Parser");
+
+  Data_Get_Struct(self, htmlParserCtxt, ctxt);
+  Data_Get_Struct(sax_handler, htmlSAXHandler, sax);
+
+  /* Free the sax handler since we'll assign our own */
+  if(ctxt->sax && ctxt->sax != (xmlSAXHandlerPtr)&xmlDefaultSAXHandler)
+    xmlFree(ctxt->sax);
+
+  ctxt->sax = sax;
+  ctxt->userData = (void *)NOKOGIRI_SAX_TUPLE_NEW(ctxt, sax_handler);
+
+  htmlParseDocument(ctxt);
+
+  if(NULL != ctxt->myDoc) xmlFreeDoc(ctxt->myDoc);
+
+  NOKOGIRI_SAX_TUPLE_DESTROY(ctxt->userData);
+  return self;
+}
+
+void init_html_sax_parser_context()
+{
+  VALUE nokogiri  = rb_define_module("Nokogiri");
+  VALUE xml       = rb_define_module_under(nokogiri, "XML");
+  VALUE html      = rb_define_module_under(nokogiri, "HTML");
+  VALUE sax       = rb_define_module_under(xml, "SAX");
+  VALUE hsax      = rb_define_module_under(html, "SAX");
+  VALUE pc        = rb_define_class_under(sax, "ParserContext", rb_cObject);
+  VALUE klass     = rb_define_class_under(hsax, "ParserContext", pc);
+
+  cNokogiriHtmlSaxParserContext = klass;
+
+  rb_define_singleton_method(klass, "memory", parse_memory, 2);
+  rb_define_singleton_method(klass, "file", parse_file, 2);
+
+  rb_define_method(klass, "parse_with", parse_with, 1);
+}

data/vendor/ruby/1.9.1/gems/nokogiri-1.5.0/ext/nokogiri/html_sax_parser_context.h

@@ -0,0 +1,11 @@
+#ifndef NOKOGIRI_HTML_SAX_PARSER_CONTEXT
+#define NOKOGIRI_HTML_SAX_PARSER_CONTEXT
+
+#include <nokogiri.h>
+
+extern VALUE cNokogiriHtmlSaxParserContext;
+
+void init_html_sax_parser_context();
+
+#endif
+

data/vendor/ruby/1.9.1/gems/nokogiri-1.5.0/ext/nokogiri/nokogiri.c

@@ -0,0 +1,115 @@
+#include <nokogiri.h>
+
+VALUE mNokogiri ;
+VALUE mNokogiriXml ;
+VALUE mNokogiriHtml ;
+VALUE mNokogiriXslt ;
+VALUE mNokogiriXmlSax ;
+VALUE mNokogiriHtmlSax ;
+
+#ifdef USE_INCLUDED_VASPRINTF
+/*
+ * I srsly hate windows.  it doesn't have vasprintf.
+ * Thank you Geoffroy Couprie for this implementation of vasprintf!
+ */
+int vasprintf (char **strp, const char *fmt, va_list ap)
+{
+  int len = vsnprintf (NULL, 0, fmt, ap) + 1;
+  char *res = (char *)malloc((unsigned int)len);
+  if (res == NULL)
+      return -1;
+  *strp = res;
+  return vsnprintf(res, (unsigned int)len, fmt, ap);
+}
+#endif
+
+#ifdef USING_SYSTEM_ALLOCATOR_LIBRARY /* Ruby Enterprise Edition with tcmalloc */
+void vasprintf_free (void *p)
+{
+  system_free(p);
+}
+#else
+void vasprintf_free (void *p)
+{
+  free(p);
+}
+#endif
+
+#ifndef __MACRUBY__
+/* Allocate strdupped strings with the same memory allocator Ruby uses. */
+static char *ruby_strdup(const char *s)
+{
+  size_t len = strlen(s);
+  char *result = ruby_xmalloc((ssize_t) (len + 1));
+  memcpy(result, s, len + 1);
+  return result;
+}
+#endif
+
+void Init_nokogiri()
+{
+#ifndef __MACRUBY__
+  xmlMemSetup(
+      (xmlFreeFunc)ruby_xfree,
+      (xmlMallocFunc)ruby_xmalloc,
+      (xmlReallocFunc)ruby_xrealloc,
+      ruby_strdup
+  );
+#endif
+
+  mNokogiri         = rb_define_module("Nokogiri");
+  mNokogiriXml      = rb_define_module_under(mNokogiri, "XML");
+  mNokogiriHtml     = rb_define_module_under(mNokogiri, "HTML");
+  mNokogiriXslt     = rb_define_module_under(mNokogiri, "XSLT");
+  mNokogiriXmlSax   = rb_define_module_under(mNokogiriXml, "SAX");
+  mNokogiriHtmlSax  = rb_define_module_under(mNokogiriHtml, "SAX");
+
+  rb_const_set( mNokogiri,
+                rb_intern("LIBXML_VERSION"),
+                NOKOGIRI_STR_NEW2(LIBXML_DOTTED_VERSION)
+              );
+  rb_const_set( mNokogiri,
+                rb_intern("LIBXML_PARSER_VERSION"),
+                NOKOGIRI_STR_NEW2(xmlParserVersion)
+              );
+
+#ifdef LIBXML_ICONV_ENABLED
+  rb_const_set(mNokogiri, rb_intern("LIBXML_ICONV_ENABLED"), Qtrue);
+#else
+  rb_const_set(mNokogiri, rb_intern("LIBXML_ICONV_ENABLED"), Qfalse);
+#endif
+
+  xmlInitParser();
+
+  init_xml_document();
+  init_html_document();
+  init_xml_node();
+  init_xml_document_fragment();
+  init_xml_text();
+  init_xml_cdata();
+  init_xml_processing_instruction();
+  init_xml_attr();
+  init_xml_entity_reference();
+  init_xml_comment();
+  init_xml_node_set();
+  init_xml_xpath_context();
+  init_xml_sax_parser_context();
+  init_xml_sax_parser();
+  init_xml_sax_push_parser();
+  init_xml_reader();
+  init_xml_dtd();
+  init_xml_element_content();
+  init_xml_attribute_decl();
+  init_xml_element_decl();
+  init_xml_entity_decl();
+  init_xml_namespace();
+  init_html_sax_parser_context();
+  init_xslt_stylesheet();
+  init_xml_syntax_error();
+  init_html_entity_lookup();
+  init_html_element_description();
+  init_xml_schema();
+  init_xml_relax_ng();
+  init_nokogiri_io();
+  init_xml_encoding_handler();
+}

data/vendor/ruby/1.9.1/gems/nokogiri-1.5.0/ext/nokogiri/nokogiri.h

@@ -0,0 +1,160 @@
+#ifndef NOKOGIRI_NATIVE
+#define NOKOGIRI_NATIVE
+
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+#include <stdarg.h>
+
+#ifdef USE_INCLUDED_VASPRINTF
+int vasprintf (char **strp, const char *fmt, va_list ap);
+#else
+
+#define _GNU_SOURCE
+#  include <stdio.h>
+#undef _GNU_SOURCE
+
+#endif
+
+#include <libxml/parser.h>
+#include <libxml/entities.h>
+#include <libxml/parserInternals.h>
+#include <libxml/xpath.h>
+#include <libxml/xpathInternals.h>
+#include <libxml/xmlreader.h>
+#include <libxml/xmlsave.h>
+#include <libxml/xmlschemas.h>
+#include <libxml/HTMLparser.h>
+#include <libxml/HTMLtree.h>
+#include <libxml/relaxng.h>
+#include <libxslt/extensions.h>
+#include <ruby.h>
+
+#ifdef HAVE_RUBY_ENCODING_H
+#include <ruby/st.h>
+#else
+#include <st.h>
+#endif
+
+#ifndef UNUSED
+# if defined(__GNUC__)
+#  define MAYBE_UNUSED(name) name __attribute__((unused))
+#  define UNUSED(name) MAYBE_UNUSED(UNUSED_ ## name)
+# else
+#  define MAYBE_UNUSED(name) name
+#  define UNUSED(name) name
+# endif
+#endif
+
+#ifndef NORETURN
+# if defined(__GNUC__)
+#  define NORETURN(name) __attribute__((noreturn)) name
+# else
+#  define NORETURN(name) name
+# endif
+#endif
+
+#ifdef HAVE_RUBY_ENCODING_H
+
+#include <ruby/encoding.h>
+
+#define NOKOGIRI_STR_NEW2(str) \
+  NOKOGIRI_STR_NEW(str, strlen((const char *)(str)))
+
+#define NOKOGIRI_STR_NEW(str, len) \
+  rb_external_str_new_with_enc((const char *)(str), (long)(len), rb_utf8_encoding())
+
+#else
+
+#define NOKOGIRI_STR_NEW2(str) \
+  rb_str_new2((const char *)(str))
+
+#define NOKOGIRI_STR_NEW(str, len) \
+  rb_str_new((const char *)(str), (long)(len))
+#endif
+
+#define RBSTR_OR_QNIL(_str) \
+  (_str ? NOKOGIRI_STR_NEW2(_str) : Qnil)
+
+#include <xml_libxml2_hacks.h>
+
+#include <xml_io.h>
+#include <xml_document.h>
+#include <html_entity_lookup.h>
+#include <html_document.h>
+#include <xml_node.h>
+#include <xml_text.h>
+#include <xml_cdata.h>
+#include <xml_attr.h>
+#include <xml_processing_instruction.h>
+#include <xml_entity_reference.h>
+#include <xml_document_fragment.h>
+#include <xml_comment.h>
+#include <xml_node_set.h>
+#include <xml_dtd.h>
+#include <xml_attribute_decl.h>
+#include <xml_element_decl.h>
+#include <xml_entity_decl.h>
+#include <xml_xpath_context.h>
+#include <xml_element_content.h>
+#include <xml_sax_parser_context.h>
+#include <xml_sax_parser.h>
+#include <xml_sax_push_parser.h>
+#include <xml_reader.h>
+#include <html_sax_parser_context.h>
+#include <xslt_stylesheet.h>
+#include <xml_syntax_error.h>
+#include <xml_schema.h>
+#include <xml_relax_ng.h>
+#include <html_element_description.h>
+#include <xml_namespace.h>
+#include <xml_encoding_handler.h>
+
+extern VALUE mNokogiri ;
+extern VALUE mNokogiriXml ;
+extern VALUE mNokogiriXmlSax ;
+extern VALUE mNokogiriHtml ;
+extern VALUE mNokogiriHtmlSax ;
+extern VALUE mNokogiriXslt ;
+
+#define NOKOGIRI_ROOT_NODE(_node) \
+  st_insert(((nokogiriTuplePtr)(_node)->doc->_private)->unlinkedNodes, (st_data_t)(_node), (st_data_t)(_node))
+
+#define NOKOGIRI_ROOT_NSDEF(_nsDef, _doc)     \
+  st_insert(((nokogiriTuplePtr)(_doc)->_private)->unlinkedNodes, (st_data_t)(_nsDef), (st_data_t)(_nsDef))
+
+#ifdef DEBUG
+
+#define NOKOGIRI_DEBUG_START(p) if (getenv("NOKOGIRI_NO_FREE")) return ; if (getenv("NOKOGIRI_DEBUG")) fprintf(stderr,"nokogiri: %s:%d %p start\n", __FILE__, __LINE__, p);
+#define NOKOGIRI_DEBUG_END(p) if (getenv("NOKOGIRI_DEBUG")) fprintf(stderr,"nokogiri: %s:%d %p end\n", __FILE__, __LINE__, p);
+
+#else
+
+#define NOKOGIRI_DEBUG_START(p)
+#define NOKOGIRI_DEBUG_END(p)
+
+#endif
+
+#ifndef RSTRING_PTR
+#define RSTRING_PTR(s) (RSTRING(s)->ptr)
+#endif
+
+#ifndef RSTRING_LEN
+#define RSTRING_LEN(s) (RSTRING(s)->len)
+#endif
+
+#ifndef RARRAY_PTR
+#define RARRAY_PTR(a) RARRAY(a)->ptr
+#endif
+
+#ifndef RARRAY_LEN
+#define RARRAY_LEN(a) RARRAY(a)->len
+#endif
+
+#ifndef __builtin_expect
+# if defined(__GNUC__)
+#  define __builtin_expect(expr, c) __builtin_expect((long)(expr), (long)(c))
+# endif
+#endif
+
+#endif