vtd_xml 0.0.3-java

data/bundle/jruby/1.9/gems/nokogiri-1.6.1-java/ext/nokogiri/xml_xpath_context.c

@@ -0,0 +1,319 @@
+#include <xml_xpath_context.h>
+
+int vasprintf (char **strp, const char *fmt, va_list ap);
+
+static void deallocate(xmlXPathContextPtr ctx)
+{
+  NOKOGIRI_DEBUG_START(ctx);
+  xmlXPathFreeContext(ctx);
+  NOKOGIRI_DEBUG_END(ctx);
+}
+
+/*
+ * call-seq:
+ *  register_ns(prefix, uri)
+ *
+ * Register the namespace with +prefix+ and +uri+.
+ */
+static VALUE register_ns(VALUE self, VALUE prefix, VALUE uri)
+{
+  xmlXPathContextPtr ctx;
+  Data_Get_Struct(self, xmlXPathContext, ctx);
+
+  xmlXPathRegisterNs( ctx,
+                      (const xmlChar *)StringValuePtr(prefix),
+                      (const xmlChar *)StringValuePtr(uri)
+  );
+  return self;
+}
+
+/*
+ * call-seq:
+ *  register_variable(name, value)
+ *
+ * Register the variable +name+ with +value+.
+ */
+static VALUE register_variable(VALUE self, VALUE name, VALUE value)
+{
+   xmlXPathContextPtr ctx;
+   xmlXPathObjectPtr xmlValue;
+   Data_Get_Struct(self, xmlXPathContext, ctx);
+
+   xmlValue = xmlXPathNewCString(StringValuePtr(value));
+
+   xmlXPathRegisterVariable( ctx,
+      (const xmlChar *)StringValuePtr(name),
+      xmlValue
+   );
+
+   return self;
+}
+
+void Nokogiri_marshal_xpath_funcall_and_return_values(xmlXPathParserContextPtr ctx, int nargs, VALUE handler, const char* function_name)
+{
+  int i;
+  VALUE result, doc;
+  VALUE *argv;
+  VALUE node_set = Qnil;
+  xmlNodeSetPtr xml_node_set = NULL;
+  xmlXPathObjectPtr obj;
+  nokogiriNodeSetTuple *node_set_tuple;
+
+  assert(ctx->context->doc);
+  assert(DOC_RUBY_OBJECT_TEST(ctx->context->doc));
+
+  argv = (VALUE *)calloc((size_t)nargs, sizeof(VALUE));
+  for (i = 0 ; i < nargs ; ++i) {
+    rb_gc_register_address(&argv[i]);
+  }
+
+  doc = DOC_RUBY_OBJECT(ctx->context->doc);
+
+  if (nargs > 0) {
+    i = nargs - 1;
+    do {
+      obj = valuePop(ctx);
+      switch(obj->type) {
+        case XPATH_STRING:
+          argv[i] = NOKOGIRI_STR_NEW2(obj->stringval);
+          break;
+        case XPATH_BOOLEAN:
+          argv[i] = obj->boolval == 1 ? Qtrue : Qfalse;
+          break;
+        case XPATH_NUMBER:
+          argv[i] = rb_float_new(obj->floatval);
+          break;
+        case XPATH_NODESET:
+          argv[i] = Nokogiri_wrap_xml_node_set(obj->nodesetval, doc);
+          break;
+        default:
+          argv[i] = NOKOGIRI_STR_NEW2(xmlXPathCastToString(obj));
+      }
+      xmlXPathFreeNodeSetList(obj);
+    } while(i-- > 0);
+  }
+
+  result = rb_funcall2(handler, rb_intern((const char*)function_name), nargs, argv);
+
+  for (i = 0 ; i < nargs ; ++i) {
+    rb_gc_unregister_address(&argv[i]);
+  }
+  free(argv);
+
+  switch(TYPE(result)) {
+    case T_FLOAT:
+    case T_BIGNUM:
+    case T_FIXNUM:
+      xmlXPathReturnNumber(ctx, NUM2DBL(result));
+      break;
+    case T_STRING:
+      xmlXPathReturnString(
+          ctx,
+          xmlCharStrdup(StringValuePtr(result))
+      );
+      break;
+    case T_TRUE:
+      xmlXPathReturnTrue(ctx);
+      break;
+    case T_FALSE:
+      xmlXPathReturnFalse(ctx);
+      break;
+    case T_NIL:
+      break;
+    case T_ARRAY:
+      {
+        VALUE args[2];
+	args[0] = doc;
+	args[1] = result;
+        node_set = rb_class_new_instance(2, args, cNokogiriXmlNodeSet);
+        Data_Get_Struct(node_set, nokogiriNodeSetTuple, node_set_tuple);
+	xml_node_set = node_set_tuple->node_set;
+        xmlXPathReturnNodeSet(ctx, xmlXPathNodeSetMerge(NULL, xml_node_set));
+      }
+      break;
+    case T_DATA:
+      if(rb_obj_is_kind_of(result, cNokogiriXmlNodeSet)) {
+        Data_Get_Struct(result, nokogiriNodeSetTuple, node_set_tuple);
+	xml_node_set = node_set_tuple->node_set;
+        /* Copy the node set, otherwise it will get GC'd. */
+        xmlXPathReturnNodeSet(ctx, xmlXPathNodeSetMerge(NULL, xml_node_set));
+        break;
+      }
+    default:
+      rb_raise(rb_eRuntimeError, "Invalid return type");
+  }
+}
+
+static void ruby_funcall(xmlXPathParserContextPtr ctx, int nargs)
+{
+  VALUE handler = Qnil;
+  const char *function = NULL ;
+
+  assert(ctx);
+  assert(ctx->context);
+  assert(ctx->context->userData);
+  assert(ctx->context->function);
+
+  handler = (VALUE)(ctx->context->userData);
+  function = (const char*)(ctx->context->function);
+
+  Nokogiri_marshal_xpath_funcall_and_return_values(ctx, nargs, handler, function);
+}
+
+static xmlXPathFunction lookup( void *ctx,
+                                const xmlChar * name,
+                                const xmlChar* ns_uri )
+{
+  VALUE xpath_handler = (VALUE)ctx;
+  if(rb_respond_to(xpath_handler, rb_intern((const char *)name)))
+    return ruby_funcall;
+
+  return NULL;
+}
+
+NORETURN(static void xpath_exception_handler(void * ctx, xmlErrorPtr error));
+static void xpath_exception_handler(void * ctx, xmlErrorPtr error)
+{
+  VALUE xpath = rb_const_get(mNokogiriXml, rb_intern("XPath"));
+  VALUE klass = rb_const_get(xpath, rb_intern("SyntaxError"));
+
+  rb_exc_raise(Nokogiri_wrap_xml_syntax_error(klass, error));
+}
+
+NORETURN(static void xpath_generic_exception_handler(void * ctx, const char *msg, ...));
+static void xpath_generic_exception_handler(void * ctx, const char *msg, ...)
+{
+  char * message;
+
+  va_list args;
+  va_start(args, msg);
+  vasprintf(&message, msg, args);
+  va_end(args);
+
+  rb_raise(rb_eRuntimeError, "%s", message);
+}
+
+/*
+ * call-seq:
+ *  evaluate(search_path, handler = nil)
+ *
+ * Evaluate the +search_path+ returning an XML::XPath object.
+ */
+static VALUE evaluate(int argc, VALUE *argv, VALUE self)
+{
+  VALUE search_path, xpath_handler;
+  VALUE thing = Qnil;
+  xmlXPathContextPtr ctx;
+  xmlXPathObjectPtr xpath;
+  xmlChar *query;
+
+  Data_Get_Struct(self, xmlXPathContext, ctx);
+
+  if(rb_scan_args(argc, argv, "11", &search_path, &xpath_handler) == 1)
+    xpath_handler = Qnil;
+
+  query = (xmlChar *)StringValuePtr(search_path);
+
+  if(Qnil != xpath_handler) {
+    /* FIXME: not sure if this is the correct place to shove private data. */
+    ctx->userData = (void *)xpath_handler;
+    xmlXPathRegisterFuncLookup(ctx, lookup, (void *)xpath_handler);
+  }
+
+  xmlResetLastError();
+  xmlSetStructuredErrorFunc(NULL, xpath_exception_handler);
+
+  /* For some reason, xmlXPathEvalExpression will blow up with a generic error */
+  /* when there is a non existent function. */
+  xmlSetGenericErrorFunc(NULL, xpath_generic_exception_handler);
+
+  xpath = xmlXPathEvalExpression(query, ctx);
+  xmlSetStructuredErrorFunc(NULL, NULL);
+  xmlSetGenericErrorFunc(NULL, NULL);
+
+  if(xpath == NULL) {
+    VALUE xpath = rb_const_get(mNokogiriXml, rb_intern("XPath"));
+    VALUE klass = rb_const_get(xpath, rb_intern("SyntaxError"));
+
+    xmlErrorPtr error = xmlGetLastError();
+    rb_exc_raise(Nokogiri_wrap_xml_syntax_error(klass, error));
+  }
+
+  assert(ctx->doc);
+  assert(DOC_RUBY_OBJECT_TEST(ctx->doc));
+
+  switch(xpath->type) {
+    case XPATH_STRING:
+      thing = NOKOGIRI_STR_NEW2(xpath->stringval);
+      xmlFree(xpath->stringval);
+      break;
+    case XPATH_NODESET:
+      if(NULL == xpath->nodesetval) {
+        thing = Nokogiri_wrap_xml_node_set(xmlXPathNodeSetCreate(NULL),
+          DOC_RUBY_OBJECT(ctx->doc));
+      } else {
+        thing = Nokogiri_wrap_xml_node_set(xpath->nodesetval,
+            DOC_RUBY_OBJECT(ctx->doc));
+      }
+      break;
+    case XPATH_NUMBER:
+      thing = rb_float_new(xpath->floatval);
+      break;
+    case XPATH_BOOLEAN:
+      thing = xpath->boolval == 1 ? Qtrue : Qfalse;
+      break;
+    default:
+      thing = Nokogiri_wrap_xml_node_set(xmlXPathNodeSetCreate(NULL),
+        DOC_RUBY_OBJECT(ctx->doc));
+  }
+
+  xmlXPathFreeNodeSetList(xpath);
+
+  return thing;
+}
+
+/*
+ * call-seq:
+ *  new(node)
+ *
+ * Create a new XPathContext with +node+ as the reference point.
+ */
+static VALUE new(VALUE klass, VALUE nodeobj)
+{
+  xmlNodePtr node;
+  xmlXPathContextPtr ctx;
+  VALUE self;
+
+  xmlXPathInit();
+
+  Data_Get_Struct(nodeobj, xmlNode, node);
+
+  ctx = xmlXPathNewContext(node->doc);
+  ctx->node = node;
+  self = Data_Wrap_Struct(klass, 0, deallocate, ctx);
+  /*rb_iv_set(self, "@xpath_handler", Qnil); */
+  return self;
+}
+
+VALUE cNokogiriXmlXpathContext;
+void init_xml_xpath_context(void)
+{
+  VALUE module = rb_define_module("Nokogiri");
+
+  /*
+   * Nokogiri::XML
+   */
+  VALUE xml = rb_define_module_under(module, "XML");
+
+  /*
+   * XPathContext is the entry point for searching a Document by using XPath.
+   */
+  VALUE klass = rb_define_class_under(xml, "XPathContext", rb_cObject);
+
+  cNokogiriXmlXpathContext = klass;
+
+  rb_define_singleton_method(klass, "new", new, 1);
+  rb_define_method(klass, "evaluate", evaluate, -1);
+  rb_define_method(klass, "register_variable", register_variable, 2);
+  rb_define_method(klass, "register_ns", register_ns, 2);
+}

data/bundle/jruby/1.9/gems/nokogiri-1.6.1-java/ext/nokogiri/xml_xpath_context.h

@@ -0,0 +1,10 @@
+#ifndef NOKOGIRI_XML_XPATH_CONTEXT
+#define NOKOGIRI_XML_XPATH_CONTEXT
+
+#include <nokogiri.h>
+
+void init_xml_xpath_context();
+void Nokogiri_marshal_xpath_funcall_and_return_values(xmlXPathParserContextPtr ctx, int nargs, VALUE handler, const char* function_name) ;
+
+extern VALUE cNokogiriXmlXpathContext;
+#endif

data/bundle/jruby/1.9/gems/nokogiri-1.6.1-java/ext/nokogiri/xslt_stylesheet.c

@@ -0,0 +1,270 @@
+#include <xslt_stylesheet.h>
+
+#include <libxslt/xsltInternals.h>
+#include <libxslt/xsltutils.h>
+#include <libxslt/transform.h>
+#include <libexslt/exslt.h>
+
+VALUE xslt;
+
+int vasprintf (char **strp, const char *fmt, va_list ap);
+void vasprintf_free (void *p);
+
+static void mark(nokogiriXsltStylesheetTuple *wrapper)
+{
+  rb_gc_mark(wrapper->func_instances);
+}
+
+static void dealloc(nokogiriXsltStylesheetTuple *wrapper)
+{
+    xsltStylesheetPtr doc = wrapper->ss;
+
+    NOKOGIRI_DEBUG_START(doc);
+    xsltFreeStylesheet(doc); /* commented out for now. */
+    NOKOGIRI_DEBUG_END(doc);
+    
+    free(wrapper);
+}
+
+static void xslt_generic_error_handler(void * ctx, const char *msg, ...)
+{
+  char * message;
+
+  va_list args;
+  va_start(args, msg);
+  vasprintf(&message, msg, args);
+  va_end(args);
+
+  rb_str_cat2((VALUE)ctx, message);
+
+  vasprintf_free(message);
+}
+
+VALUE Nokogiri_wrap_xslt_stylesheet(xsltStylesheetPtr ss)
+{
+  VALUE self;
+  nokogiriXsltStylesheetTuple *wrapper;
+
+  self = Data_Make_Struct(cNokogiriXsltStylesheet, nokogiriXsltStylesheetTuple,
+                          mark, dealloc, wrapper);
+  
+  ss->_private = (void *)self;
+  wrapper->ss = ss;
+  wrapper->func_instances = rb_ary_new();
+
+  return self;
+}
+
+/*
+ * call-seq:
+ *   parse_stylesheet_doc(document)
+ *
+ * Parse a stylesheet from +document+.
+ */
+static VALUE parse_stylesheet_doc(VALUE klass, VALUE xmldocobj)
+{
+    xmlDocPtr xml, xml_cpy;
+    VALUE errstr, exception;
+    xsltStylesheetPtr ss ;
+    Data_Get_Struct(xmldocobj, xmlDoc, xml);
+    exsltRegisterAll();
+
+    errstr = rb_str_new(0, 0);
+    xsltSetGenericErrorFunc((void *)errstr, xslt_generic_error_handler);
+
+    xml_cpy = xmlCopyDoc(xml, 1); /* 1 => recursive */
+    ss = xsltParseStylesheetDoc(xml_cpy);
+
+    xsltSetGenericErrorFunc(NULL, NULL);
+
+    if (!ss) {
+	xmlFreeDoc(xml_cpy);
+	exception = rb_exc_new3(rb_eRuntimeError, errstr);
+	rb_exc_raise(exception);
+    }
+
+    return Nokogiri_wrap_xslt_stylesheet(ss);
+}
+
+
+/*
+ * call-seq:
+ *   serialize(document)
+ *
+ * Serialize +document+ to an xml string.
+ */
+static VALUE serialize(VALUE self, VALUE xmlobj)
+{
+    xmlDocPtr xml ;
+    nokogiriXsltStylesheetTuple *wrapper;
+    xmlChar* doc_ptr ;
+    int doc_len ;
+    VALUE rval ;
+
+    Data_Get_Struct(xmlobj, xmlDoc, xml);
+    Data_Get_Struct(self, nokogiriXsltStylesheetTuple, wrapper);
+    xsltSaveResultToString(&doc_ptr, &doc_len, xml, wrapper->ss);
+    rval = NOKOGIRI_STR_NEW(doc_ptr, doc_len);
+    xmlFree(doc_ptr);
+    return rval ;
+}
+
+static void swallow_superfluous_xml_errors(void * userdata, xmlErrorPtr error, ...)
+{
+}
+
+/*
+ *  call-seq:
+ *    transform(document, params = [])
+ *
+ *  Apply an XSLT stylesheet to an XML::Document.
+ *  +params+ is an array of strings used as XSLT parameters.
+ *  returns Nokogiri::XML::Document
+ *
+ *  Example:
+ * 
+ *    doc   = Nokogiri::XML(File.read(ARGV[0]))
+ *    xslt  = Nokogiri::XSLT(File.read(ARGV[1]))
+ *    puts xslt.transform(doc, ['key', 'value'])
+ *
+ */
+static VALUE transform(int argc, VALUE* argv, VALUE self)
+{
+    VALUE xmldoc, paramobj, errstr, exception ;
+    xmlDocPtr xml ;
+    xmlDocPtr result ;
+    nokogiriXsltStylesheetTuple *wrapper;
+    const char** params ;
+    long param_len, j ;
+    int parse_error_occurred ;
+
+    rb_scan_args(argc, argv, "11", &xmldoc, &paramobj);
+    if (NIL_P(paramobj)) { paramobj = rb_ary_new2(0L) ; }
+    if (!rb_obj_is_kind_of(xmldoc, cNokogiriXmlDocument))
+      rb_raise(rb_eArgError, "argument must be a Nokogiri::XML::Document");
+
+    /* handle hashes as arguments. */
+    if(T_HASH == TYPE(paramobj)) {
+      paramobj = rb_funcall(paramobj, rb_intern("to_a"), 0);
+      paramobj = rb_funcall(paramobj, rb_intern("flatten"), 0);
+    }
+
+    Check_Type(paramobj, T_ARRAY);
+
+    Data_Get_Struct(xmldoc, xmlDoc, xml);
+    Data_Get_Struct(self, nokogiriXsltStylesheetTuple, wrapper);
+
+    param_len = RARRAY_LEN(paramobj);
+    params = calloc((size_t)param_len+1, sizeof(char*));
+    for (j = 0 ; j < param_len ; j++) {
+      VALUE entry = rb_ary_entry(paramobj, j);
+      const char * ptr = StringValuePtr(entry);
+      params[j] = ptr;
+    }
+    params[param_len] = 0 ;
+
+    errstr = rb_str_new(0, 0);
+    xsltSetGenericErrorFunc((void *)errstr, xslt_generic_error_handler);
+    xmlSetGenericErrorFunc(NULL, (xmlGenericErrorFunc)&swallow_superfluous_xml_errors);
+
+    result = xsltApplyStylesheet(wrapper->ss, xml, params);
+    free(params);
+
+    xsltSetGenericErrorFunc(NULL, NULL);
+    xmlSetGenericErrorFunc(NULL, NULL);
+
+    parse_error_occurred = (Qfalse == rb_funcall(errstr, rb_intern("empty?"), 0));
+
+    if (parse_error_occurred) {
+      exception = rb_exc_new3(rb_eRuntimeError, errstr);
+      rb_exc_raise(exception);
+    }
+
+    return Nokogiri_wrap_xml_document((VALUE)0, result) ;
+}
+
+static void method_caller(xmlXPathParserContextPtr ctxt, int nargs)
+{
+    VALUE handler;
+    const char *function_name;
+    xsltTransformContextPtr transform;
+    const xmlChar *functionURI;
+
+    transform = xsltXPathGetTransformContext(ctxt);
+    functionURI = ctxt->context->functionURI;
+    handler = (VALUE)xsltGetExtData(transform, functionURI);
+    function_name = (const char*)(ctxt->context->function);
+
+    Nokogiri_marshal_xpath_funcall_and_return_values(ctxt, nargs, handler, (const char*)function_name);
+}
+
+static void * initFunc(xsltTransformContextPtr ctxt, const xmlChar *uri)
+{
+    VALUE modules = rb_iv_get(xslt, "@modules");
+    VALUE obj = rb_hash_aref(modules, rb_str_new2((const char *)uri));
+    VALUE args = { Qfalse };
+    VALUE methods = rb_funcall(obj, rb_intern("instance_methods"), 1, args);
+    VALUE inst;
+    nokogiriXsltStylesheetTuple *wrapper;
+    int i;
+
+    for(i = 0; i < RARRAY_LEN(methods); i++) {
+	VALUE method_name = rb_obj_as_string(rb_ary_entry(methods, i));
+	xsltRegisterExtFunction(ctxt,
+          (unsigned char *)StringValuePtr(method_name), uri, method_caller);
+    }
+
+    Data_Get_Struct(ctxt->style->_private, nokogiriXsltStylesheetTuple,
+                    wrapper);
+    inst = rb_class_new_instance(0, NULL, obj);
+    rb_ary_push(wrapper->func_instances, inst);
+
+    return (void *)inst;
+}
+
+static void shutdownFunc(xsltTransformContextPtr ctxt,
+	const xmlChar *uri, void *data)
+{
+    nokogiriXsltStylesheetTuple *wrapper;
+
+    Data_Get_Struct(ctxt->style->_private, nokogiriXsltStylesheetTuple,
+                    wrapper);
+
+    rb_ary_clear(wrapper->func_instances);
+}
+
+/*
+ *  call-seq:
+ *    register(uri, custom_handler_class)
+ *
+ *  Register a class that implements custom XLST transformation functions.
+ */
+static VALUE registr(VALUE self, VALUE uri, VALUE obj)
+{
+    VALUE modules = rb_iv_get(self, "@modules");
+    if(NIL_P(modules)) rb_raise(rb_eRuntimeError, "wtf! @modules isn't set");
+
+    rb_hash_aset(modules, uri, obj);
+    xsltRegisterExtModule((unsigned char *)StringValuePtr(uri), initFunc, shutdownFunc);
+    return self;
+}
+
+VALUE cNokogiriXsltStylesheet ;
+void init_xslt_stylesheet()
+{
+  VALUE nokogiri;
+  VALUE klass;
+
+  nokogiri = rb_define_module("Nokogiri");
+  xslt = rb_define_module_under(nokogiri, "XSLT");
+  klass = rb_define_class_under(xslt, "Stylesheet", rb_cObject);
+
+  rb_iv_set(xslt, "@modules", rb_hash_new());
+
+  cNokogiriXsltStylesheet = klass;
+
+  rb_define_singleton_method(klass, "parse_stylesheet_doc", parse_stylesheet_doc, 1);
+  rb_define_singleton_method(xslt, "register", registr, 2);
+  rb_define_method(klass, "serialize", serialize, 1);
+  rb_define_method(klass, "transform", transform, -1);
+}

data/bundle/jruby/1.9/gems/nokogiri-1.6.1-java/ext/nokogiri/xslt_stylesheet.h

@@ -0,0 +1,14 @@
+#ifndef NOKOGIRI_XSLT_STYLESHEET
+#define NOKOGIRI_XSLT_STYLESHEET
+
+#include <nokogiri.h>
+
+void init_xslt_stylesheet();
+
+extern VALUE cNokogiriXsltStylesheet ;
+
+typedef struct _nokogiriXsltStylesheetTuple {
+  xsltStylesheetPtr ss;
+  VALUE func_instances;
+} nokogiriXsltStylesheetTuple;
+#endif