gss 0.0.5

data/vendor/bundle/ruby/1.9.1/gems/nokogiri-1.6.2.1-x86-mingw32/ext/nokogiri/xml_sax_parser.h

@@ -0,0 +1,39 @@
+#ifndef NOKOGIRI_XML_SAX_PARSER
+#define NOKOGIRI_XML_SAX_PARSER
+
+#include <nokogiri.h>
+
+void init_xml_sax_parser();
+
+extern VALUE cNokogiriXmlSaxParser ;
+
+typedef struct _nokogiriSAXTuple {
+  xmlParserCtxtPtr  ctxt;
+  VALUE             self;
+} nokogiriSAXTuple;
+
+typedef nokogiriSAXTuple * nokogiriSAXTuplePtr;
+
+#define NOKOGIRI_SAX_SELF(_ctxt) \
+  ((nokogiriSAXTuplePtr)(_ctxt))->self
+
+#define NOKOGIRI_SAX_CTXT(_ctxt) \
+  ((nokogiriSAXTuplePtr)(_ctxt))->ctxt
+
+#define NOKOGIRI_SAX_TUPLE_NEW(_ctxt, _self) \
+  nokogiri_sax_tuple_new(_ctxt, _self)
+
+static inline nokogiriSAXTuplePtr
+nokogiri_sax_tuple_new(xmlParserCtxtPtr ctxt, VALUE self)
+{
+  nokogiriSAXTuplePtr tuple = malloc(sizeof(nokogiriSAXTuple));
+  tuple->self = self;
+  tuple->ctxt = ctxt;
+  return tuple;
+}
+
+#define NOKOGIRI_SAX_TUPLE_DESTROY(_tuple) \
+  free(_tuple) \
+
+#endif
+

data/vendor/bundle/ruby/1.9.1/gems/nokogiri-1.6.2.1-x86-mingw32/ext/nokogiri/xml_sax_parser_context.c

@@ -0,0 +1,262 @@
+#include <xml_sax_parser_context.h>
+
+VALUE cNokogiriXmlSaxParserContext ;
+
+static void deallocate(xmlParserCtxtPtr ctxt)
+{
+  NOKOGIRI_DEBUG_START(handler);
+
+  ctxt->sax = NULL;
+
+  xmlFreeParserCtxt(ctxt);
+
+  NOKOGIRI_DEBUG_END(handler);
+}
+
+/*
+ * call-seq:
+ *  parse_io(io, encoding)
+ *
+ * Parse +io+ object with +encoding+
+ */
+static VALUE
+parse_io(VALUE klass, VALUE io, VALUE encoding)
+{
+    xmlParserCtxtPtr ctxt;
+    xmlCharEncoding enc = (xmlCharEncoding)NUM2INT(encoding);
+
+    ctxt = xmlCreateIOParserCtxt(NULL, NULL,
+				 (xmlInputReadCallback)io_read_callback,
+				 (xmlInputCloseCallback)io_close_callback,
+				 (void *)io, enc);
+    if (ctxt->sax) {
+	xmlFree(ctxt->sax);
+	ctxt->sax = NULL;
+    }
+
+    return Data_Wrap_Struct(klass, NULL, deallocate, ctxt);
+}
+
+/*
+ * call-seq:
+ *  parse_file(filename)
+ *
+ * Parse file given +filename+
+ */
+static VALUE parse_file(VALUE klass, VALUE filename)
+{
+  xmlParserCtxtPtr ctxt = xmlCreateFileParserCtxt(StringValuePtr(filename));
+  return Data_Wrap_Struct(klass, NULL, deallocate, ctxt);
+}
+
+/*
+ * call-seq:
+ *  parse_memory(data)
+ *
+ * Parse the XML stored in memory in +data+
+ */
+static VALUE
+parse_memory(VALUE klass, VALUE data)
+{
+    xmlParserCtxtPtr 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 = xmlCreateMemoryParserCtxt(StringValuePtr(data),
+				     (int)RSTRING_LEN(data));
+    if (ctxt->sax) {
+	xmlFree(ctxt->sax);
+	ctxt->sax = NULL;
+    }
+
+    return Data_Wrap_Struct(klass, NULL, deallocate, ctxt);
+}
+
+static VALUE
+parse_doc(VALUE ctxt_val)
+{
+    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr)ctxt_val;
+    xmlParseDocument(ctxt);
+    return Qnil;
+}
+
+static VALUE
+parse_doc_finalize(VALUE ctxt_val)
+{
+    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr)ctxt_val;
+
+    if (NULL != ctxt->myDoc)
+	xmlFreeDoc(ctxt->myDoc);
+
+    NOKOGIRI_SAX_TUPLE_DESTROY(ctxt->userData);
+    return Qnil;
+}
+
+/*
+ * call-seq:
+ *  parse_with(sax_handler)
+ *
+ * Use +sax_handler+ and parse the current document
+ */
+static VALUE
+parse_with(VALUE self, VALUE sax_handler)
+{
+    xmlParserCtxtPtr ctxt;
+    xmlSAXHandlerPtr 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, xmlParserCtxt, ctxt);
+    Data_Get_Struct(sax_handler, xmlSAXHandler, 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);
+
+    rb_ensure(parse_doc, (VALUE)ctxt, parse_doc_finalize, (VALUE)ctxt);
+
+    return Qnil;
+}
+
+/*
+ * call-seq:
+ *  replace_entities=(boolean)
+ *
+ * Should this parser replace entities?  &amp; will get converted to '&' if
+ * set to true
+ */
+static VALUE set_replace_entities(VALUE self, VALUE value)
+{
+  xmlParserCtxtPtr ctxt;
+  Data_Get_Struct(self, xmlParserCtxt, ctxt);
+
+  if(Qfalse == value)
+    ctxt->replaceEntities = 0;
+  else
+    ctxt->replaceEntities = 1;
+
+  return value;
+}
+
+/*
+ * call-seq:
+ *  replace_entities
+ *
+ * Should this parser replace entities?  &amp; will get converted to '&' if
+ * set to true
+ */
+static VALUE get_replace_entities(VALUE self)
+{
+  xmlParserCtxtPtr ctxt;
+  Data_Get_Struct(self, xmlParserCtxt, ctxt);
+
+  if(0 == ctxt->replaceEntities)
+    return Qfalse;
+  else
+    return Qtrue;
+}
+
+/*
+ * call-seq: line
+ *
+ * Get the current line the parser context is processing.
+ */
+static VALUE line(VALUE self)
+{
+  xmlParserCtxtPtr ctxt;
+  xmlParserInputPtr io;
+
+  Data_Get_Struct(self, xmlParserCtxt, ctxt);
+
+  io = ctxt->input;
+  if(io)
+    return INT2NUM(io->line);
+
+  return Qnil;
+}
+
+/*
+ * call-seq: column
+ *
+ * Get the current column the parser context is processing.
+ */
+static VALUE column(VALUE self)
+{
+  xmlParserCtxtPtr ctxt;
+  xmlParserInputPtr io;
+
+  Data_Get_Struct(self, xmlParserCtxt, ctxt);
+
+  io = ctxt->input;
+  if(io)
+    return INT2NUM(io->col);
+
+  return Qnil;
+}
+
+/*
+ * call-seq:
+ *  recovery=(boolean)
+ *
+ * Should this parser recover from structural errors? It will not stop processing
+ * file on structural errors if if set to true
+ */
+static VALUE set_recovery(VALUE self, VALUE value)
+{
+  xmlParserCtxtPtr ctxt;
+  Data_Get_Struct(self, xmlParserCtxt, ctxt);
+
+  if(value == Qfalse)
+    ctxt->recovery = 0;
+  else
+    ctxt->recovery = 1;
+
+  return value;
+}
+
+/*
+ * call-seq:
+ *  recovery
+ *
+ * Should this parser recover from structural errors? It will not stop processing
+ * file on structural errors if if set to true
+ */
+static VALUE get_recovery(VALUE self)
+{
+  xmlParserCtxtPtr ctxt;
+  Data_Get_Struct(self, xmlParserCtxt, ctxt);
+
+  if(ctxt->recovery == 0)
+    return Qfalse;
+  else
+    return Qtrue;
+}
+
+void init_xml_sax_parser_context()
+{
+  VALUE nokogiri  = rb_define_module("Nokogiri");
+  VALUE xml       = rb_define_module_under(nokogiri, "XML");
+  VALUE sax       = rb_define_module_under(xml, "SAX");
+  VALUE klass     = rb_define_class_under(sax, "ParserContext", rb_cObject);
+
+  cNokogiriXmlSaxParserContext = klass;
+
+  rb_define_singleton_method(klass, "io", parse_io, 2);
+  rb_define_singleton_method(klass, "memory", parse_memory, 1);
+  rb_define_singleton_method(klass, "file", parse_file, 1);
+
+  rb_define_method(klass, "parse_with", parse_with, 1);
+  rb_define_method(klass, "replace_entities=", set_replace_entities, 1);
+  rb_define_method(klass, "replace_entities", get_replace_entities, 0);
+  rb_define_method(klass, "recovery=", set_recovery, 1);
+  rb_define_method(klass, "recovery", get_recovery, 0);
+  rb_define_method(klass, "line", line, 0);
+  rb_define_method(klass, "column", column, 0);
+}

data/vendor/bundle/ruby/1.9.1/gems/nokogiri-1.6.2.1-x86-mingw32/ext/nokogiri/xml_sax_parser_context.h

@@ -0,0 +1,10 @@
+#ifndef NOKOGIRI_XML_SAX_PARSER_CONTEXT
+#define NOKOGIRI_XML_SAX_PARSER_CONTEXT
+
+#include <nokogiri.h>
+
+extern VALUE cNokogiriXmlSaxParserContext;
+
+void init_xml_sax_parser_context();
+
+#endif

data/vendor/bundle/ruby/1.9.1/gems/nokogiri-1.6.2.1-x86-mingw32/ext/nokogiri/xml_sax_push_parser.c

@@ -0,0 +1,115 @@
+#include <xml_sax_push_parser.h>
+
+static void deallocate(xmlParserCtxtPtr ctx)
+{
+  NOKOGIRI_DEBUG_START(ctx);
+  if(ctx != NULL) {
+    NOKOGIRI_SAX_TUPLE_DESTROY(ctx->userData);
+    xmlFreeParserCtxt(ctx);
+  }
+  NOKOGIRI_DEBUG_END(ctx);
+}
+
+static VALUE allocate(VALUE klass)
+{
+  return Data_Wrap_Struct(klass, NULL, deallocate, NULL);
+}
+
+/*
+ * call-seq:
+ *  native_write(chunk, last_chunk)
+ *
+ * Write +chunk+ to PushParser. +last_chunk+ triggers the end_document handle
+ */
+static VALUE native_write(VALUE self, VALUE _chunk, VALUE _last_chunk)
+{
+  xmlParserCtxtPtr ctx;
+  const char * chunk  = NULL;
+  int size            = 0;
+
+
+  Data_Get_Struct(self, xmlParserCtxt, ctx);
+
+  if(Qnil != _chunk) {
+    chunk = StringValuePtr(_chunk);
+    size = (int)RSTRING_LEN(_chunk);
+  }
+
+  if(xmlParseChunk(ctx, chunk, size, Qtrue == _last_chunk ? 1 : 0)) {
+    if (!(ctx->options & XML_PARSE_RECOVER)) {
+      xmlErrorPtr e = xmlCtxtGetLastError(ctx);
+      Nokogiri_error_raise(NULL, e);
+    }
+  }
+
+  return self;
+}
+
+/*
+ * call-seq:
+ *  initialize_native(xml_sax, filename)
+ *
+ * Initialize the push parser with +xml_sax+ using +filename+
+ */
+static VALUE initialize_native(VALUE self, VALUE _xml_sax, VALUE _filename)
+{
+  xmlSAXHandlerPtr sax;
+  const char * filename = NULL;
+  xmlParserCtxtPtr ctx;
+
+  Data_Get_Struct(_xml_sax, xmlSAXHandler, sax);
+
+  if(_filename != Qnil) filename = StringValuePtr(_filename);
+
+  ctx = xmlCreatePushParserCtxt(
+      sax,
+      NULL,
+      NULL,
+      0,
+      filename
+  );
+  if(ctx == NULL)
+    rb_raise(rb_eRuntimeError, "Could not create a parser context");
+
+  ctx->userData = NOKOGIRI_SAX_TUPLE_NEW(ctx, self);
+
+  ctx->sax2 = 1;
+  DATA_PTR(self) = ctx;
+  return self;
+}
+
+static VALUE get_options(VALUE self)
+{
+  xmlParserCtxtPtr ctx;
+  Data_Get_Struct(self, xmlParserCtxt, ctx);
+
+  return INT2NUM(ctx->options);
+}
+
+static VALUE set_options(VALUE self, VALUE options)
+{
+  xmlParserCtxtPtr ctx;
+  Data_Get_Struct(self, xmlParserCtxt, ctx);
+
+  if (xmlCtxtUseOptions(ctx, (int)NUM2INT(options)) != 0)
+    rb_raise(rb_eRuntimeError, "Cannot set XML parser context options");
+
+  return Qnil;
+}
+
+VALUE cNokogiriXmlSaxPushParser ;
+void init_xml_sax_push_parser()
+{
+  VALUE nokogiri = rb_define_module("Nokogiri");
+  VALUE xml = rb_define_module_under(nokogiri, "XML");
+  VALUE sax = rb_define_module_under(xml, "SAX");
+  VALUE klass = rb_define_class_under(sax, "PushParser", rb_cObject);
+
+  cNokogiriXmlSaxPushParser = klass;
+
+  rb_define_alloc_func(klass, allocate);
+  rb_define_private_method(klass, "initialize_native", initialize_native, 2);
+  rb_define_private_method(klass, "native_write", native_write, 2);
+  rb_define_method(klass, "options", get_options, 0);
+  rb_define_method(klass, "options=", set_options, 1);
+}

data/vendor/bundle/ruby/1.9.1/gems/nokogiri-1.6.2.1-x86-mingw32/ext/nokogiri/xml_sax_push_parser.h

@@ -0,0 +1,9 @@
+#ifndef NOKOGIRI_XML_SAX_PUSH_PARSER
+#define NOKOGIRI_XML_SAX_PUSH_PARSER
+
+#include <nokogiri.h>
+
+void init_xml_sax_push_parser();
+
+extern VALUE cNokogiriXmlSaxPushParser ;
+#endif

data/vendor/bundle/ruby/1.9.1/gems/nokogiri-1.6.2.1-x86-mingw32/ext/nokogiri/xml_schema.c

@@ -0,0 +1,205 @@
+#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;
+  xmlSchemaValidCtxtPtr valid_ctxt;
+  VALUE errors;
+
+  Data_Get_Struct(self, xmlSchema, schema);
+  Data_Get_Struct(document, xmlDoc, doc);
+
+  errors = rb_ary_new();
+
+  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:
+ *  validate_file(filename)
+ *
+ * Validate a file against this Schema.
+ */
+static VALUE validate_file(VALUE self, VALUE rb_filename)
+{
+  xmlSchemaPtr schema;
+  xmlSchemaValidCtxtPtr valid_ctxt;
+  const char *filename ;
+  VALUE errors;
+
+  Data_Get_Struct(self, xmlSchema, schema);
+  filename = (const char*)StringValuePtr(rb_filename) ;
+
+  errors = rb_ary_new();
+
+  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
+
+  xmlSchemaValidateFile(valid_ctxt, filename, 0);
+
+  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)
+{
+  xmlSchemaPtr schema;
+  xmlSchemaParserCtxtPtr ctx = xmlSchemaNewMemParserCtxt(
+      (const char *)StringValuePtr(content),
+      (int)RSTRING_LEN(content)
+  );
+  VALUE rb_schema;
+  VALUE errors = rb_ary_new();
+  xmlSetStructuredErrorFunc((void *)errors, Nokogiri_error_array_pusher);
+
+#ifdef HAVE_XMLSCHEMASETPARSERSTRUCTUREDERRORS
+  xmlSchemaSetParserStructuredErrors(
+    ctx,
+    Nokogiri_error_array_pusher,
+    (void *)errors
+  );
+#endif
+
+   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;
+  }
+
+  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;
+  xmlSchemaParserCtxtPtr ctx;
+  xmlSchemaPtr schema;
+  VALUE errors;
+  VALUE rb_schema;
+
+  Data_Get_Struct(document, xmlDoc, doc);
+
+  /* In case someone passes us a node. ugh. */
+  doc = doc->doc;
+
+  ctx = xmlSchemaNewDocParserCtxt(doc);
+
+  errors = rb_ary_new();
+  xmlSetStructuredErrorFunc((void *)errors, Nokogiri_error_array_pusher);
+
+#ifdef HAVE_XMLSCHEMASETPARSERSTRUCTUREDERRORS
+  xmlSchemaSetParserStructuredErrors(
+    ctx,
+    Nokogiri_error_array_pusher,
+    (void *)errors
+  );
+#endif
+
+  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;
+  }
+
+  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);
+  rb_define_private_method(klass, "validate_file",     validate_file, 1);
+}