nokogiri-backupify 1.5.0.beta.4

data/ext/nokogiri/xml_xpath_context.h

@@ -0,0 +1,9 @@
+#ifndef NOKOGIRI_XML_XPATH_CONTEXT
+#define NOKOGIRI_XML_XPATH_CONTEXT
+
+#include <nokogiri.h>
+
+void init_xml_xpath_context();
+
+extern VALUE cNokogiriXmlXpathContext;
+#endif

data/ext/nokogiri/xslt_stylesheet.c

@@ -0,0 +1,258 @@
+#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);
+
+static void dealloc(xsltStylesheetPtr doc)
+{
+    NOKOGIRI_DEBUG_START(doc);
+    xsltFreeStylesheet(doc); /* commented out for now. */
+    NOKOGIRI_DEBUG_END(doc);
+}
+
+NORETURN(static void xslt_generic_error_handler(void * ctx, const char *msg, ...));
+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_exc_raise(rb_exc_new2(rb_eRuntimeError, message));
+}
+
+/*
+ * call-seq:
+ *   parse_stylesheet_doc(document)
+ *
+ * Parse a stylesheet from +document+.
+ */
+static VALUE parse_stylesheet_doc(VALUE klass, VALUE xmldocobj)
+{
+    xmlDocPtr xml ;
+    xsltStylesheetPtr ss ;
+    Data_Get_Struct(xmldocobj, xmlDoc, xml);
+    exsltRegisterAll();
+
+    xsltSetGenericErrorFunc(NULL, xslt_generic_error_handler);
+
+    ss = xsltParseStylesheetDoc(xmlCopyDoc(xml, 1)); /* 1 => recursive */
+
+    xsltSetGenericErrorFunc(NULL, NULL);
+
+    return Data_Wrap_Struct(klass, NULL, dealloc, ss);
+}
+
+
+/*
+ * call-seq:
+ *   serialize(document)
+ *
+ * Serialize +document+ to an xml string.
+ */
+static VALUE serialize(VALUE self, VALUE xmlobj)
+{
+    xmlDocPtr xml ;
+    xsltStylesheetPtr ss ;
+    xmlChar* doc_ptr ;
+    int doc_len ;
+    VALUE rval ;
+
+    Data_Get_Struct(xmlobj, xmlDoc, xml);
+    Data_Get_Struct(self, xsltStylesheet, ss);
+    xsltSaveResultToString(&doc_ptr, &doc_len, xml, ss);
+    rval = NOKOGIRI_STR_NEW(doc_ptr, doc_len);
+    xmlFree(doc_ptr);
+    return rval ;
+}
+
+/*
+ *  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 ;
+    xmlDocPtr xml ;
+    xmlDocPtr result ;
+    xsltStylesheetPtr ss ;
+    const char** params ;
+    long param_len, j ;
+
+    rb_scan_args(argc, argv, "11", &xmldoc, &paramobj);
+    if (NIL_P(paramobj)) { paramobj = rb_ary_new2(0L) ; }
+
+    /* 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, xsltStylesheet, ss);
+
+    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 ;
+
+    result = xsltApplyStylesheet(ss, xml, params);
+    free(params);
+
+    if (!result) rb_raise(rb_eRuntimeError, "could not perform xslt transform on document");
+
+    return Nokogiri_wrap_xml_document((VALUE)0, result) ;
+}
+
+static void method_caller(xmlXPathParserContextPtr ctxt, int nargs)
+{
+    const xmlChar * function;
+    const xmlChar * functionURI;
+    size_t i, count;
+
+    xsltTransformContextPtr transform;
+    xmlXPathObjectPtr xpath;
+    VALUE obj;
+    VALUE *args;
+    VALUE result;
+
+    transform = xsltXPathGetTransformContext(ctxt);
+
+    function = ctxt->context->function;
+    functionURI = ctxt->context->functionURI;
+    obj = (VALUE)xsltGetExtData(transform, functionURI);
+
+    count = (size_t)ctxt->valueNr;
+    args = calloc(count, sizeof(VALUE *));
+
+    for(i = 0; i < count; i++) {
+	VALUE thing;
+
+	xpath = valuePop(ctxt);
+	switch(xpath->type) {
+	    case XPATH_STRING:
+		thing = NOKOGIRI_STR_NEW2(xpath->stringval);
+		break;
+	    case XPATH_NODESET:
+		if(NULL == xpath->nodesetval) {
+		    thing = Nokogiri_wrap_xml_node_set(
+			    xmlXPathNodeSetCreate(NULL),
+			    DOC_RUBY_OBJECT(ctxt->context->doc));
+		} else {
+		    thing = Nokogiri_wrap_xml_node_set(xpath->nodesetval,
+			    DOC_RUBY_OBJECT(ctxt->context->doc));
+		}
+		break;
+	    default:
+		rb_raise(rb_eRuntimeError, "do not handle type: %d", xpath->type);
+	}
+	args[i] = thing;
+    }
+    result = rb_funcall3(obj, rb_intern((const char *)function), (int)count, args);
+    switch(TYPE(result)) {
+	case T_FLOAT:
+	case T_BIGNUM:
+	case T_FIXNUM:
+	    xmlXPathReturnNumber(ctxt, NUM2DBL(result));
+	    break;
+	case T_STRING:
+	    xmlXPathReturnString(
+		    ctxt,
+		    xmlStrdup((xmlChar *)StringValuePtr(result))
+		    );
+	    break;
+	case T_TRUE:
+	    xmlXPathReturnTrue(ctxt);
+	    break;
+	case T_FALSE:
+	    xmlXPathReturnFalse(ctxt);
+	    break;
+	case T_NIL:
+	    break;
+	default:
+	    rb_raise(rb_eRuntimeError, "Invalid return type");
+    }
+}
+
+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);
+    int i;
+
+    for(i = 0; i < RARRAY_LEN(methods); i++) {
+	VALUE method_name = rb_obj_as_string(RARRAY_PTR(methods)[i]);
+	xsltRegisterExtFunction(ctxt,
+          (unsigned char *)StringValuePtr(method_name), uri, method_caller);
+    }
+
+    return (void *)rb_class_new_instance(0, NULL, obj);
+}
+
+static void shutdownFunc(xsltTransformContextPtr ctxt,
+	const xmlChar *uri, void *data)
+{
+}
+
+/*
+ *  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/ext/nokogiri/xslt_stylesheet.h

@@ -0,0 +1,9 @@
+#ifndef NOKOGIRI_XSLT_STYLESHEET
+#define NOKOGIRI_XSLT_STYLESHEET
+
+#include <nokogiri.h>
+
+void init_xslt_stylesheet();
+
+extern VALUE cNokogiriXsltStylesheet ;
+#endif

data/lib/nokogiri.rb

@@ -0,0 +1,143 @@
+# -*- coding: utf-8 -*-
+# Modify the PATH on windows so that the external DLLs will get loaded.
+
+require 'rbconfig'
+ENV['PATH'] = [File.expand_path(
+  File.join(File.dirname(__FILE__), "..", "ext", "nokogiri")
+), ENV['PATH']].compact.join(';') if RbConfig::CONFIG['host_os'] =~ /(mswin|mingw)/i
+
+if defined?(RUBY_ENGINE) && RUBY_ENGINE == "jruby"
+  # If JRuby::Rack::VERSION is defined, Nokogiri is in a servlet. 
+  # If AppEngine::ApiProxy is defined, Nokogiri is on Google App Egnine.
+  # These two cases don't need to require jar archives because those
+  # should be in WEB-INF/lib and already set in the classpath by
+  # a servlet container.
+  unless defined?(JRuby::Rack::VERSION) || defined?(AppEngine::ApiProxy)
+    require 'isorelax.jar'
+    require 'jing.jar'
+    require 'nekohtml.jar'
+    require 'nekodtd.jar'
+    require 'xercesImpl.jar'
+  end
+  require 'nokogiri/nokogiri'
+else
+  require 'nokogiri/nokogiri'
+end
+
+warn(<<-eowarn) if '1.8.6' == RUBY_VERSION && $VERBOSE
+!!! DEPRECATION WARNING !!!
+Hey Champ!  I see you're using Ruby 1.8.6!  While I applaud you for sticking to
+your guns and using The One True Ruby, I have to let you know that we're going
+to stop supporting 1.8.6.  I know, it's sad.  But, we just don't have time to
+support every version of Ruby out there.  Whether we like it or not, time moves
+forward and so does our software.
+
+On August 1, 2010, we will no longer support Ruby 1.8.6.  If nokogiri happens to
+work on 1.8.6 after that date, then great!  We will hownever, no longer test,
+use, or endorse 1.8.6 as a supported platform.
+
+Thanks,
+
+  Team Nokogiri
+eowarn
+
+require 'nokogiri/version'
+require 'nokogiri/syntax_error'
+require 'nokogiri/xml'
+require 'nokogiri/xslt'
+require 'nokogiri/html'
+require 'nokogiri/decorators/slop'
+require 'nokogiri/css'
+require 'nokogiri/html/builder'
+
+# Nokogiri parses and searches XML/HTML very quickly, and also has
+# correctly implemented CSS3 selector support as well as XPath support.
+#
+# Parsing a document returns either a Nokogiri::XML::Document, or a
+# Nokogiri::HTML::Document depending on the kind of document you parse.
+#
+# Here is an example:
+#
+#   require 'nokogiri'
+#   require 'open-uri'
+#
+#   # Get a Nokogiri::HTML:Document for the page we’re interested in...
+#
+#   doc = Nokogiri::HTML(open('http://www.google.com/search?q=tenderlove'))
+#
+#   # Do funky things with it using Nokogiri::XML::Node methods...
+#
+#   ####
+#   # Search for nodes by css
+#   doc.css('h3.r a.l').each do |link|
+#     puts link.content
+#   end
+#
+# See Nokogiri::XML::Node#css for more information about CSS searching.
+# See Nokogiri::XML::Node#xpath for more information about XPath searching.
+module Nokogiri
+  class << self
+    ###
+    # Parse an HTML or XML document.  +string+ contains the document.
+    def parse string, url = nil, encoding = nil, options = nil
+      doc =
+        if string.respond_to?(:read) ||
+          string =~ /^\s*<[^Hh>]*html/i # Probably html
+          Nokogiri::HTML(
+            string,
+            url,
+            encoding, options || XML::ParseOptions::DEFAULT_HTML
+          )
+        else
+          Nokogiri::XML(string, url, encoding,
+                        options || XML::ParseOptions::DEFAULT_XML)
+        end
+      yield doc if block_given?
+      doc
+    end
+
+    ###
+    # Create a new Nokogiri::XML::DocumentFragment
+    def make input = nil, opts = {}, &blk
+      if input
+        Nokogiri::HTML.fragment(input).children.first
+      else
+        Nokogiri(&blk)
+      end
+    end
+
+    ###
+    # Parse a document and add the Slop decorator.  The Slop decorator
+    # implements method_missing such that methods may be used instead of CSS
+    # or XPath.  For example:
+    #
+    #   doc = Nokogiri::Slop(<<-eohtml)
+    #     <html>
+    #       <body>
+    #         <p>first</p>
+    #         <p>second</p>
+    #       </body>
+    #     </html>
+    #   eohtml
+    #   assert_equal('second', doc.html.body.p[1].text)
+    #
+    def Slop(*args, &block)
+      Nokogiri(*args, &block).slop!
+    end
+  end
+end
+
+###
+# Parser a document contained in +args+.  Nokogiri will try to guess what
+# type of document you are attempting to parse.  For more information, see
+# Nokogiri.parse
+#
+# To specify the type of document, use Nokogiri.XML or Nokogiri.HTML.
+def Nokogiri(*args, &block)
+  if block_given?
+    builder = Nokogiri::HTML::Builder.new(&block)
+    return builder.doc.root
+  else
+    Nokogiri.parse(*args)
+  end
+end

data/lib/nokogiri/css.rb

@@ -0,0 +1,23 @@
+require 'nokogiri/css/node'
+require 'nokogiri/css/xpath_visitor'
+require 'nokogiri/css/parser'
+require 'nokogiri/css/tokenizer'
+require 'nokogiri/css/syntax_error'
+
+module Nokogiri
+  module CSS
+    class << self
+      ###
+      # Parse this CSS selector in +selector+.  Returns an AST.
+      def parse selector
+        Parser.new.parse selector
+      end
+
+      ###
+      # Get the XPath for +selector+.
+      def xpath_for selector, options={}
+        Parser.new(options[:ns] || {}).xpath_for selector, options
+      end
+    end
+  end
+end