nokogiri 1.2.3-java → 1.3.0-java

data/lib/nokogiri/css/xpath_visitor.rb

@@ -1,6 +1,6 @@
 module Nokogiri
   module CSS
-    class XPathVisitor
+    class XPathVisitor # :nodoc:
       def visit_function node
         #  note that nth-child and nth-last-child are preprocessed in css/node.rb.
         msg = :"visit_function_#{node.value.first.gsub(/[(]/, '')}"
@@ -76,15 +76,19 @@ module Nokogiri
         value = "'#{value}'" if value !~ /^['"]/
 
         case node.value[1]
-        when '*='
+        when :equal
+          attribute + " = " + "#{value}"
+        when :not_equal
+          attribute + " != " + "#{value}"
+        when :substring_match
           "contains(#{attribute}, #{value})"
-        when '^='
+        when :prefix_match
           "starts-with(#{attribute}, #{value})"
-        when '|='
+        when :dash_match
           "#{attribute} = #{value} or starts-with(#{attribute}, concat(#{value}, '-'))"
-        when '~='
+        when :includes
           "contains(concat(\" \", #{attribute}, \" \"),concat(\" \", #{value}, \" \"))"
-        when '$='
+        when :suffix_match
           "substring(#{attribute}, string-length(#{attribute}) - " +
             "string-length(#{value}) + 1, string-length(#{value})) = #{value}"
         else

data/lib/nokogiri/decorators/hpricot/node.rb

@@ -1,7 +1,7 @@
 module Nokogiri
   module Decorators
     module Hpricot
-      module Node
+      module Node # :nodoc:
         def search *paths
           ns = paths.last.is_a?(Hash) ? paths.pop : {}
           converted = paths.map { |path|

data/lib/nokogiri/decorators/hpricot/node_set.rb

@@ -6,7 +6,7 @@ module Nokogiri
         # Select nodes matching the supplied rule.
         # Note that positional rules (like <tt>:nth()</tt>) aren't currently supported.
         #
-        # example: 
+        # example:
         #   node_set.filter('.ohmy')          # selects nodes from the set with class "ohmy"
         #   node_set.filter('a#link2')        # selects nodes from the set with child node <a id='link2'>
         #   node_set.filter('a[@id="link2"]') # selects nodes from the set with child node <a id='link2'>
@@ -29,7 +29,7 @@ module Nokogiri
         end
 
       private
-        def filter_transformer(transformer, rule)
+        def filter_transformer(transformer, rule) # :nodoc:
           sub_set = XML::NodeSet.new(document)
           document.decorate(sub_set)
 

data/lib/nokogiri/decorators/hpricot/xpath_visitor.rb

@@ -4,6 +4,8 @@ module Nokogiri
       ####
       # This mixin does custom adjustments to deal with _whyML
       module XPathVisitor
+        ###
+        # Visit attribute condition nodes with +node+
         def visit_attribute_condition node
           unless (node.value.first.type == :FUNCTION) or (node.value.first.value.first =~ /^@/)
             node.value.first.value[0] = "child::" +

data/lib/nokogiri/decorators/slop.rb

@@ -4,6 +4,8 @@ module Nokogiri
     # The Slop decorator implements method missing such that a methods may be
     # used instead of XPath or CSS.  See Nokogiri.Slop
     module Slop
+      ###
+      # look for node with +name+.  See Nokogiri.Slop
       def method_missing name, *args, &block
         if args.empty?
           list = xpath("./#{name}")
@@ -22,7 +24,7 @@ module Nokogiri
             )
           end
         end
-        
+
         super if list.empty?
         list.length == 1 ? list.first : list
       end

data/lib/nokogiri/ffi/html/document.rb

@@ -0,0 +1,37 @@
+module Nokogiri
+  module HTML
+    class Document < XML::Document
+
+      attr_accessor :cstruct # :nodoc:
+
+      def self.new(*args) # :nodoc:
+        uri         = args[0]
+        external_id = args[1]
+        doc = wrap(LibXML.htmlNewDoc(uri, external_id))
+        doc.send :initialize, *args
+        doc
+      end
+
+      def self.read_io(io, url, encoding, options) # :nodoc:
+        wrap_with_error_handling do
+          LibXML.htmlReadIO(IoCallbacks.reader(io), nil, nil, url, encoding, options)
+        end
+      end
+
+      def self.read_memory(string, url, encoding, options) # :nodoc:
+        wrap_with_error_handling do
+          LibXML.htmlReadMemory(string, string.length, url, encoding, options)
+        end
+      end
+
+      def meta_encoding=(encoding) # :nodoc:
+        LibXML.htmlSetMetaEncoding(cstruct, encoding)
+        encoding
+      end
+
+      def meta_encoding # :nodoc:
+        LibXML.htmlGetMetaEncoding(cstruct)
+      end
+    end
+  end
+end

data/lib/nokogiri/ffi/html/element_description.rb

@@ -0,0 +1,85 @@
+module Nokogiri
+  module HTML
+    class ElementDescription
+
+      attr_accessor :cstruct # :nodoc:
+
+      def required_attributes # :nodoc:
+        get_string_array_from :attrs_req
+      end
+
+      def deprecated_attributes # :nodoc:
+        get_string_array_from :attrs_depr
+      end
+
+      def optional_attributes # :nodoc:
+        get_string_array_from :attrs_opt
+      end
+
+      def default_sub_element # :nodoc:
+        cstruct[:defaultsubelt]
+      end
+
+      def sub_elements # :nodoc:
+        get_string_array_from :subelts
+      end
+
+      def description # :nodoc:
+        cstruct[:desc]
+      end
+
+      def inline? # :nodoc:
+        cstruct[:isinline] != 0
+      end
+
+      def deprecated? # :nodoc:
+        cstruct[:depr] != 0
+      end
+
+      def empty? # :nodoc:
+        cstruct[:empty] != 0
+      end
+
+      def save_end_tag? # :nodoc:
+        cstruct[:saveEndTag] != 0
+      end
+
+      def implied_end_tag? # :nodoc:
+        cstruct[:endTag] != 0
+      end
+
+      def implied_start_tag? # :nodoc:
+        cstruct[:startTag] != 0
+      end
+
+      def name # :nodoc:
+        cstruct[:name]
+      end
+
+      def self.[](tag_name) # :nodoc:
+        ptr = LibXML.htmlTagLookup(tag_name)
+        return nil if ptr.null?
+
+        desc = allocate
+        desc.cstruct = LibXML::HtmlElemDesc.new(ptr)
+        desc
+      end
+
+      private
+
+      def get_string_array_from(sym) # :nodoc:
+        list = []
+        return list if cstruct[sym].null?
+
+        j = 0
+        while (ptr = cstruct[sym].get_pointer(j * FFI.type_size(:pointer))) && ! ptr.null?
+          list << ptr.read_string
+          j += 1
+        end
+
+        list
+      end
+
+    end
+  end
+end

data/lib/nokogiri/ffi/html/entity_lookup.rb

@@ -0,0 +1,16 @@
+module Nokogiri
+  module HTML
+    class EntityLookup
+
+      def get(key) # :nodoc:
+        ptr = LibXML.htmlEntityLookup(key.to_s)
+        return nil if ptr.null?
+
+        cstruct = LibXML::HtmlEntityDesc.new(ptr)
+        EntityDescription.new cstruct[:value], cstruct[:name], cstruct[:desc]
+      end
+
+    end
+  end
+end
+

data/lib/nokogiri/ffi/html/sax/parser.rb

@@ -0,0 +1,21 @@
+module Nokogiri
+  module HTML
+    module SAX
+      class Parser < XML::SAX::Parser
+        
+        def native_parse_file(data, encoding) # :nodoc:
+          docptr = LibXML.htmlSAXParseFile(data, encoding, cstruct, nil)
+          LibXML.xmlFreeDoc docptr
+          data
+        end
+
+        def native_parse_memory(data, encoding) # :nodoc:
+          docptr = LibXML.htmlSAXParseDoc(data, encoding, cstruct, nil)
+          LibXML.xmlFreeDoc docptr
+          data
+        end
+
+      end
+    end
+  end
+end

data/lib/nokogiri/ffi/io_callbacks.rb

@@ -0,0 +1,32 @@
+module Nokogiri
+  module IoCallbacks # :nodoc:
+    
+    class << self
+      if defined?(FFI::IO.native_read)
+        def reader(io)
+          lambda do |ctx, buffer, len|
+            rcode = FFI::IO.native_read(io, buffer, len)
+            (rcode < 0) ? 0 : rcode
+          end
+        end
+      else
+        def reader(io) # TODO: this can be removed once JRuby 1.3.0RC2 and ruby-ffi 0.4.0 are both released
+          lambda do |ctx, buffer, len|
+            string = io.read(len)
+            return 0 if string.nil?
+            buffer.put_bytes(0, string, 0, string.length)
+            string.length
+          end
+        end
+      end
+
+      def writer(io)
+        lambda do |context, buffer, len|
+          io.write buffer
+          len
+        end
+      end
+    end
+
+  end
+end

data/lib/nokogiri/ffi/libxml.rb

@@ -0,0 +1,314 @@
+
+module Nokogiri
+  module LibXML # :nodoc: all
+    extend FFI::Library
+    ffi_lib 'xml2', 'xslt', 'exslt'
+
+    # globals.c
+    attach_function :__xmlParserVersion, [], :pointer
+    attach_function :__xmlIndentTreeOutput, [], :pointer
+    attach_function :__xmlTreeIndentString, [], :pointer
+    attach_function :xmlDeregisterNodeDefault, [:pointer], :pointer
+  end
+
+  LIBXML_PARSER_VERSION = LibXML.__xmlParserVersion().read_pointer.read_string
+  LIBXML_VERSION = LIBXML_PARSER_VERSION.scan(/^(.*)(..)(..)$/).first.collect{|j|j.to_i}.join(".")
+end
+
+require 'nokogiri/version'
+
+Nokogiri::VERSION_INFO['libxml'] = {}
+Nokogiri::VERSION_INFO['libxml']['loaded'] = Nokogiri::LIBXML_VERSION
+Nokogiri::VERSION_INFO['libxml']['binding'] = 'ffi'
+if RUBY_PLATFORM =~ /java/
+  Nokogiri::VERSION_INFO['libxml']['platform'] = 'jruby'
+  raise(RuntimeError, "Nokogiri requires JRuby 1.3.0 or later") if JRUBY_VERSION < "1.3.0"
+else
+  Nokogiri::VERSION_INFO['libxml']['platform'] = 'ruby'
+end
+
+module Nokogiri
+  module LibXML # :nodoc:
+    # useful callback signatures
+    callback :syntax_error_handler, [:pointer, :pointer], :void
+    callback :generic_error_handler, [:pointer, :string], :void
+    callback :io_write_callback, [:pointer, :string, :int], :int
+    callback :io_read_callback, [:pointer, :pointer, :int], :int
+    callback :io_close_callback, [:pointer], :int
+    callback :hash_copier_callback, [:pointer, :pointer, :string], :void
+    callback :xpath_callback, [:pointer, :int], :void
+    callback :xpath_lookup_callback, [:pointer, :string, :pointer], :xpath_callback
+    callback :start_document_sax_func, [:pointer], :void
+    callback :end_document_sax_func, [:pointer], :void
+    callback :start_element_sax_func, [:pointer, :string, :pointer], :void
+    callback :end_element_sax_func, [:pointer, :string], :void
+    callback :characters_sax_func, [:pointer, :string, :int], :void
+    callback :comment_sax_func, [:pointer, :string], :void
+    callback :warning_sax_func, [:pointer, :string], :void
+    callback :error_sax_func, [:pointer, :string], :void
+    callback :cdata_block_sax_func, [:pointer, :string, :int], :void
+    callback :start_element_ns_sax2_func, [:pointer, :pointer, :pointer, :pointer, :int, :pointer, :int, :int, :pointer], :void
+    callback :end_element_ns_sax2_func, [:pointer, :pointer, :pointer, :pointer], :void
+
+    # libc
+    attach_function :calloc, [:int, :int], :pointer
+    attach_function :free, [:pointer], :void
+
+    # HTMLparser.c
+    attach_function :htmlReadMemory, [:string, :int, :string, :string, :int], :pointer
+    attach_function :htmlReadIO, [:io_read_callback, :io_close_callback, :pointer, :string, :string, :int], :pointer
+    attach_function :htmlNewDoc, [:string, :string], :pointer
+    attach_function :htmlTagLookup, [:string], :pointer
+    attach_function :htmlEntityLookup, [:string], :pointer
+    attach_function :htmlSAXParseFile, [:string, :pointer, :pointer, :pointer], :pointer # second arg 'encoding' should be a string, but we assign it as a pointer elsewhere
+    attach_function :htmlSAXParseDoc, [:pointer, :pointer, :pointer, :pointer], :pointer # second arg 'encoding' should be a string, but we assign it as a pointer elsewhere
+
+    # HTMLtree.c
+    attach_function :htmlDocDumpMemory, [:pointer, :pointer, :pointer], :void
+    attach_function :htmlNodeDump, [:pointer, :pointer, :pointer], :int
+    attach_function :htmlGetMetaEncoding, [:pointer], :string # returns const char*
+    attach_function :htmlSetMetaEncoding, [:pointer, :string], :void
+
+    # parser.c
+    attach_function :xmlReadMemory, [:string, :int, :string, :string, :int], :pointer
+    attach_function :xmlInitParser, [], :void
+    attach_function :xmlReadIO, [:io_read_callback, :io_close_callback, :pointer, :string, :string, :int], :pointer
+    attach_function :xmlCreateIOParserCtxt, [:pointer, :pointer, :io_read_callback, :io_close_callback, :pointer, :int], :pointer
+    attach_function :xmlSAXUserParseMemory, [:pointer, :pointer, :string, :int], :int
+    attach_function :xmlSAXUserParseFile, [:pointer, :pointer, :string], :int
+    attach_function :xmlParseDocument, [:pointer], :int
+    attach_function :xmlFreeParserCtxt, [:pointer], :void
+    attach_function :xmlCreatePushParserCtxt, [:pointer, :pointer, :string, :int, :string], :pointer
+    attach_function :xmlParseChunk, [:pointer, :string, :int, :int], :int
+
+    # tree.c
+    attach_function :xmlNewDoc, [:string], :pointer
+    attach_function :xmlNewDocFragment, [:pointer], :pointer
+    attach_function :xmlDocGetRootElement, [:pointer], :pointer
+    attach_function :xmlDocSetRootElement, [:pointer, :pointer], :pointer
+    attach_function :xmlCopyDoc, [:pointer, :int], :pointer
+    attach_function :xmlFreeDoc, [:pointer], :void
+    attach_function :xmlSetTreeDoc, [:pointer, :pointer], :void
+    attach_function :xmlNewReference, [:pointer, :string], :pointer
+    attach_function :xmlNewNode, [:pointer, :string], :pointer
+    attach_function :xmlCopyNode, [:pointer, :int], :pointer
+    attach_function :xmlDocCopyNode, [:pointer, :pointer, :int], :pointer
+    attach_function :xmlReplaceNode, [:pointer, :pointer], :pointer
+    attach_function :xmlUnlinkNode, [:pointer], :void
+    attach_function :xmlAddChild, [:pointer, :pointer], :pointer
+    attach_function :xmlAddNextSibling, [:pointer, :pointer], :pointer
+    attach_function :xmlAddPrevSibling, [:pointer, :pointer], :pointer
+    attach_function :xmlIsBlankNode, [:pointer], :int
+    attach_function :xmlHasProp, [:pointer, :string], :pointer
+    attach_function :xmlHasNsProp, [:pointer, :string, :string], :pointer
+    attach_function :xmlGetProp, [:pointer, :string], :pointer # returns char* that must be freed
+    attach_function :xmlSetProp, [:pointer, :string, :string], :pointer
+    attach_function :xmlRemoveProp, [:pointer], :int
+    attach_function :xmlNodeSetContent, [:pointer, :string], :void
+    attach_function :xmlNodeGetContent, [:pointer], :pointer # returns char* that must be freed
+    attach_function :xmlNodeSetName, [:pointer, :string], :void
+    attach_function :xmlGetNodePath, [:pointer], :pointer
+    attach_function :xmlNewCDataBlock, [:pointer, :string, :int], :pointer
+    attach_function :xmlNewDocComment, [:pointer, :string], :pointer
+    attach_function :xmlNewDocPI, [:pointer, :string, :string], :pointer
+    attach_function :xmlNewText, [:string], :pointer
+    attach_function :xmlFreeNode, [:pointer], :void
+    attach_function :xmlFreeNodeList, [:pointer], :void
+    attach_function :xmlEncodeEntitiesReentrant, [:pointer, :string], :pointer # returns char* that must be freed
+    attach_function :xmlStringGetNodeList, [:pointer, :pointer], :pointer # second arg should be a :string, but we only ship the results of xmlEncodeEntitiesReentrant, so let's optimize.
+    attach_function :xmlNewNs, [:pointer, :string, :string], :pointer
+    attach_function :xmlNewNsProp, [:pointer, :pointer, :string, :string], :pointer
+    attach_function :xmlSearchNsByHref, [:pointer, :pointer, :string], :pointer
+    attach_function :xmlGetIntSubset, [:pointer], :pointer
+    attach_function :xmlBufferCreate, [], :pointer
+    attach_function :xmlBufferFree, [:pointer], :void
+    attach_function :xmlSplitQName2, [:string, :pointer], :pointer # returns char* that must be freed
+    attach_function :xmlNewDocProp, [:pointer, :string, :string], :pointer
+    attach_function :xmlFreePropList, [:pointer], :void
+
+    # xmlsave.c
+    attach_function :xmlDocDumpMemory, [:pointer, :pointer, :pointer], :void
+    attach_function :xmlNodeDump, [:pointer, :pointer, :pointer, :int, :int], :int
+    attach_function :xmlSaveToIO, [:io_write_callback, :io_close_callback, :pointer, :string, :int], :pointer
+    attach_function :xmlSaveTree, [:pointer, :pointer], :int
+    attach_function :xmlSaveClose, [:pointer], :int
+    attach_function :xmlSetNs, [:pointer, :pointer], :void
+
+    # entities.c
+    attach_function :xmlEncodeSpecialChars, [:pointer, :string], :pointer # returns char* that must be freed
+
+    # xpath.c
+    attach_function :xmlXPathInit, [], :void
+    attach_function :xmlXPathNewContext, [:pointer], :pointer
+    attach_function :xmlXPathFreeContext, [:pointer], :void
+    attach_function :xmlXPathEvalExpression, [:string, :pointer], :pointer
+    attach_function :xmlXPathRegisterNs, [:pointer, :string, :string], :int
+    attach_function :xmlXPathCmpNodes, [:pointer, :pointer], :int
+    attach_function :xmlXPathNodeSetContains, [:pointer, :pointer], :int
+    attach_function :xmlXPathNodeSetAdd, [:pointer, :pointer], :void
+    attach_function :xmlXPathNodeSetRemove, [:pointer, :int], :void
+    attach_function :xmlXPathNodeSetCreate, [:pointer], :pointer
+    attach_function :xmlXPathNodeSetDel, [:pointer, :pointer], :void
+    attach_function :xmlXPathIntersection, [:pointer, :pointer], :pointer
+    attach_function :xmlXPathFreeNodeSetList, [:pointer], :void
+    attach_function :xmlXPathRegisterFuncLookup, [:pointer, :xpath_lookup_callback, :pointer], :void
+    attach_function :valuePop, [:pointer], :pointer
+    attach_function :valuePush, [:pointer, :pointer], :int
+    attach_function :xmlXPathCastToString, [:pointer], :pointer # returns char* that must be freed
+    attach_function :xmlXPathNodeSetMerge, [:pointer, :pointer], :pointer
+    attach_function :xmlXPathWrapNodeSet, [:pointer], :pointer
+    attach_function :xmlXPathWrapCString, [:pointer], :pointer # should take a :string, but we optimize
+    attach_function :xmlXPathWrapString, [:pointer], :pointer # should take a :string, but we optimize
+    attach_function :xmlXPathNewBoolean, [:int], :pointer
+    attach_function :xmlXPathNewFloat, [:double], :pointer
+
+    class << self
+      # these functions are implemented as C macros
+      def xmlXPathReturnNodeSet(ctx, ns)
+        valuePush(ctx, xmlXPathWrapNodeSet(ns))
+      end
+      def xmlXPathReturnTrue(ctx)
+        valuePush(ctx, xmlXPathNewBoolean(1))
+      end
+      def xmlXPathReturnFalse(ctx)
+        valuePush(ctx, xmlXPathNewBoolean(0))
+      end
+      def xmlXPathReturnString(ctx, str)
+        valuePush(ctx, xmlXPathWrapString(str))
+      end
+      def xmlXPathReturnNumber(ctx, val)
+        valuePush(ctx, xmlXPathNewFloat(val))
+      end
+    end
+
+    # xmlstring.c
+    attach_function :xmlStrdup, [:string], :pointer # returns char* that must be freed
+    def self.xmlFree(pointer)
+      # xmlFree is a C preprocessor macro, not an actual function
+      self.free(pointer)
+    end
+
+    # error.c
+    attach_function :xmlSetStructuredErrorFunc, [:pointer, :syntax_error_handler], :void
+    attach_function :xmlSetGenericErrorFunc, [:pointer, :generic_error_handler], :void
+    attach_function :xmlResetLastError, [], :void
+    attach_function :xmlCopyError, [:pointer, :pointer], :int
+    attach_function :xmlGetLastError, [], :pointer
+
+    # hash.c
+    attach_function :xmlHashScan, [:pointer, :hash_copier_callback, :pointer], :void
+
+    # xmlreader.c
+    attach_function :xmlReaderForMemory, [:pointer, :int, :string, :string, :int], :pointer
+    attach_function :xmlTextReaderGetAttribute, [:pointer, :string], :pointer # returns char* that must be freed
+    attach_function :xmlTextReaderGetAttributeNo, [:pointer, :int], :pointer # returns char* that must be freed
+    attach_function :xmlTextReaderLookupNamespace, [:pointer, :string], :pointer # returns char* that must be freed
+    attach_function :xmlTextReaderRead, [:pointer], :int
+    attach_function :xmlTextReaderAttributeCount, [:pointer], :int
+    attach_function :xmlTextReaderCurrentNode, [:pointer], :pointer
+    attach_function :xmlTextReaderExpand, [:pointer], :pointer
+    attach_function :xmlTextReaderIsDefault, [:pointer], :int
+    attach_function :xmlTextReaderDepth, [:pointer], :int
+    attach_function :xmlTextReaderConstXmlLang, [:pointer], :pointer # returns a const char*, but must check for null
+    attach_function :xmlTextReaderConstLocalName, [:pointer], :pointer # returns a const char* that is deallocated with the reader
+    attach_function :xmlTextReaderConstName, [:pointer], :pointer # returns a const char* that is deallocated with the reader
+    attach_function :xmlTextReaderConstNamespaceUri, [:pointer], :pointer # returns a const char* that is deallocated with the reader
+    attach_function :xmlTextReaderConstPrefix, [:pointer], :pointer # returns a const char* that is deallocated with the reader
+    attach_function :xmlTextReaderConstValue, [:pointer], :pointer # returns a const char* that is deallocated on the next read()
+    attach_function :xmlTextReaderConstXmlVersion, [:pointer], :pointer # returns a const char* that is deallocated with the reader
+    attach_function :xmlTextReaderReadState, [:pointer], :int
+    attach_function :xmlTextReaderHasValue, [:pointer], :int
+    attach_function :xmlFreeTextReader, [:pointer], :void
+    attach_function :xmlReaderForIO, [:io_read_callback, :io_close_callback, :pointer, :string, :string, :int], :pointer
+
+    # xslt.c
+    attach_function :xsltParseStylesheetDoc, [:pointer], :pointer
+    attach_function :xsltFreeStylesheet, [:pointer], :void
+    attach_function :xsltApplyStylesheet, [:pointer, :pointer, :pointer], :pointer
+    attach_function :xsltSaveResultToString, [:pointer, :pointer, :pointer, :pointer], :int
+    attach_function :xsltSetGenericErrorFunc, [:pointer, :generic_error_handler], :void
+
+    # exslt.c
+    attach_function :exsltRegisterAll, [], :void
+
+    # xmlschemas.c
+    attach_function :xmlSchemaNewValidCtxt, [:pointer], :pointer
+    attach_function :xmlSchemaSetValidStructuredErrors, [:pointer, :syntax_error_handler, :pointer], :void unless Nokogiri.is_2_6_16?
+    attach_function :xmlSchemaValidateDoc, [:pointer, :pointer], :void
+    attach_function :xmlSchemaFreeValidCtxt, [:pointer], :void
+    attach_function :xmlSchemaNewMemParserCtxt, [:pointer, :int], :pointer # first arg could be string, but we pass length, so let's optimize
+    attach_function :xmlSchemaSetParserStructuredErrors, [:pointer, :syntax_error_handler, :pointer], :void unless Nokogiri.is_2_6_16?
+    attach_function :xmlSchemaParse, [:pointer], :pointer
+    attach_function :xmlSchemaFreeParserCtxt, [:pointer], :void
+
+    # relaxng.c
+    attach_function :xmlRelaxNGNewValidCtxt, [:pointer], :pointer
+    attach_function :xmlRelaxNGSetValidStructuredErrors, [:pointer, :syntax_error_handler, :pointer], :void unless Nokogiri.is_2_6_16?
+    attach_function :xmlRelaxNGValidateDoc, [:pointer, :pointer], :int
+    attach_function :xmlRelaxNGFreeValidCtxt, [:pointer], :void
+    attach_function :xmlRelaxNGNewMemParserCtxt, [:pointer, :int], :pointer # first arg could be string, but we pass length, so let's optimize
+    attach_function :xmlRelaxNGSetParserStructuredErrors, [:pointer, :syntax_error_handler, :pointer], :void unless Nokogiri.is_2_6_16?
+    attach_function :xmlRelaxNGParse, [:pointer], :pointer
+    attach_function :xmlRelaxNGFreeParserCtxt, [:pointer], :void
+
+    # helpers
+    def self.pointer_offset(n)
+      n * FFI.type_size(:pointer) # byte offset of nth pointer in an array of pointers
+    end
+  end
+end
+
+require 'nokogiri/syntax_error'
+require 'nokogiri/xml/syntax_error'
+
+[ "io_callbacks",
+  "structs/common_node",
+  "structs/xml_alloc",
+  "structs/xml_document",
+  "structs/xml_node",
+  "structs/xml_dtd",
+  "structs/xml_notation",
+  "structs/xml_node_set",
+  "structs/xml_xpath_context",
+  "structs/xml_xpath_object",
+  "structs/xml_xpath_parser_context",
+  "structs/xml_buffer",
+  "structs/xml_syntax_error",
+  "structs/xml_attr",
+  "structs/xml_ns",
+  "structs/xml_schema",
+  "structs/xml_relax_ng",
+  "structs/xml_text_reader",
+  "structs/xml_sax_handler",
+  "structs/xml_sax_push_parser_context",
+  "structs/html_elem_desc",
+  "structs/html_entity_desc",
+  "structs/xslt_stylesheet",
+  "xml/node",
+  "xml/namespace",
+  "xml/dtd",
+  "xml/attr",
+  "xml/document",
+  "xml/document_fragment",
+  "xml/schema",
+  "xml/relax_ng",
+  "xml/text",
+  "xml/cdata",
+  "xml/comment",
+  "xml/processing_instruction",
+  "xml/node_set",
+  "xml/xpath",
+  "xml/xpath_context",
+  "xml/syntax_error",
+  "xml/reader",
+  "xml/entity_reference",
+  "xml/sax/parser",
+  "xml/sax/push_parser",
+  "html/document",
+  "html/element_description",
+  "html/entity_lookup",
+  "html/sax/parser",
+  "xslt/stylesheet",
+].each do |file|
+  require File.join(File.dirname(__FILE__), file)
+end