nokogiri 1.2.3 → 1.3.0

data/lib/nokogiri/ffi/structs/common_node.rb

@@ -0,0 +1,26 @@
+module Nokogiri
+  module LibXML # :nodoc:
+    module CommonNode # :nodoc:
+
+      def document
+        p = self[:doc]
+        p.null? ? nil : LibXML::XmlDocumentCast.new(p)
+      end
+
+      def ruby_node
+        self[:_private] != 0 ? ObjectSpace._id2ref(self[:_private]) : nil
+      end
+
+      def ruby_node=(object)
+        self[:_private] = object.object_id
+      end
+
+      def keep_reference_from_document! # equivalent to NOKOGIRI_ROOT_NODE
+        doc = self.document
+        raise "no document to add reference to" unless doc
+        LibXML.xmlXPathNodeSetAdd(doc.node_set, self)
+      end
+    end
+  end
+end
+

data/lib/nokogiri/ffi/structs/html_elem_desc.rb

@@ -0,0 +1,24 @@
+module Nokogiri
+  module LibXML # :nodoc:
+    class HtmlElemDesc < FFI::Struct # :nodoc:
+
+      layout(
+        :name,          :string,
+        :startTag,      :char,
+        :endTag,        :char,
+        :saveEndTag,    :char,
+        :empty,         :char,
+        :depr,          :char,
+        :dtd,           :char,
+        :isinline,      :char,
+        :desc,          :string,
+        :subelts,       :pointer,
+        :defaultsubelt, :string,
+        :attrs_opt,     :pointer,
+        :attrs_depr,    :pointer,
+        :attrs_req,     :pointer
+        )
+        
+    end
+  end
+end

data/lib/nokogiri/ffi/structs/html_entity_desc.rb

@@ -0,0 +1,13 @@
+module Nokogiri
+  module LibXML # :nodoc:
+    class HtmlEntityDesc < FFI::Struct # :nodoc:
+
+      layout(
+        :value, :int,
+        :name,  :char,
+        :desc,  :char
+        )
+
+    end
+  end
+end

data/lib/nokogiri/ffi/structs/xml_alloc.rb

@@ -0,0 +1,16 @@
+module Nokogiri
+  module LibXML # :nodoc:
+    #
+    #  this class only exists to create a xmlFree() finalizer
+    #
+    class XmlAlloc < FFI::ManagedStruct # :nodoc:
+
+      layout :dummy, :int, 0 # to avoid @layout warnings
+
+      def self.release ptr
+        LibXML.xmlFree(ptr)
+      end
+
+    end
+  end
+end

data/lib/nokogiri/ffi/structs/xml_attr.rb

@@ -0,0 +1,19 @@
+module Nokogiri
+  module LibXML # :nodoc:
+    class XmlAttr < FFI::Struct # :nodoc:
+
+      layout(
+        :_private,      :pointer,
+        :type,          :int,
+        :name,          :string,
+        :children,      :pointer,
+        :last,          :pointer,
+        :parent,        :pointer,
+        :next,          :pointer,
+        :prev,          :pointer,
+        :doc,           :pointer
+        )
+
+    end
+  end
+end

data/lib/nokogiri/ffi/structs/xml_buffer.rb

@@ -0,0 +1,16 @@
+module Nokogiri
+  module LibXML # :nodoc:
+    class XmlBuffer < FFI::ManagedStruct # :nodoc:
+
+      layout(
+        :content,       :string,
+        :use,           :int,
+        :size,          :int
+        )
+
+      def self.release ptr
+        LibXML.xmlBufferFree(ptr)
+      end
+    end
+  end
+end

data/lib/nokogiri/ffi/structs/xml_document.rb

@@ -0,0 +1,108 @@
+module Nokogiri
+  module LibXML # :nodoc:
+
+    module XmlDocumentMixin # :nodoc:
+      def self.included(base)
+        base.class_eval do
+
+          layout(
+            :_private,  :pointer,
+            :type,      :int,
+            :name,      :string,
+            :children,  :pointer,
+            :last,      :pointer,
+            :parent,    :pointer,
+            :next,      :pointer,
+            :prev,      :pointer,
+            :doc,       :pointer,
+
+            :compression,       :int,
+            :standalone,        :int,
+            :intSubset,         :pointer,
+            :extSubset,         :pointer,
+            :oldNs,             :pointer,
+            :version,           :string,
+            :encoding,          :pointer,
+            :ids,               :pointer,
+            :refs,              :pointer,
+            :URL,               :string
+            )
+
+        end
+      end
+
+      def document
+        p = self[:doc]
+        p.null? ? nil : LibXML::XmlDocumentCast.new(p)
+      end
+
+      def ruby_doc
+        ptr = self[:_private]
+        return nil if ptr.null?
+        ObjectSpace._id2ref(ptr.get_long(0))
+      end
+
+      def ruby_doc=(object)
+        self[:_private].put_long(0, object.object_id)
+      end
+
+      def node_set
+        LibXML::XmlNodeSetCast.new(self[:_private].get_pointer(FFI.type_size(:pointer)))
+      end
+
+      def alloc_tuple
+        self[:_private] = LibXML.calloc(FFI.type_size(:pointer), 2)
+        self[:_private].put_pointer(FFI.type_size(:pointer), LibXML.xmlXPathNodeSetCreate(nil))
+      end
+    end
+
+    #
+    #  use at the point of creation, so we can be sure the document will be GCed properly
+    #
+    class XmlDocument < FFI::ManagedStruct # :nodoc:
+      include XmlDocumentMixin
+
+      def initialize(ptr)
+        super(ptr)
+        self.alloc_tuple
+      end
+
+      def self.release ptr
+        doc = LibXML::XmlDocumentCast.new(ptr)
+        func = LibXML.xmlDeregisterNodeDefault(nil)
+        begin
+          ns  = LibXML::XmlNodeSetCast.new(doc[:_private].get_pointer(LibXML.pointer_offset(1)))
+
+          ns[:nodeNr].times do |j|
+            node_cstruct = LibXML::XmlNode.new(ns[:nodeTab].get_pointer(LibXML.pointer_offset(j)))
+            case node_cstruct[:type]
+            when Nokogiri::XML::Node::ATTRIBUTE_NODE
+              LibXML.xmlFreePropList(node_cstruct)
+            else
+              LibXML.xmlAddChild(doc, node_cstruct) if node_cstruct[:parent].null?
+            end
+          end
+          LibXML::XmlNodeSet.release(ns.pointer)
+
+          LibXML.free(doc[:_private])
+        rescue
+          puts "Nokogiri::LibXML::XmlDocument.release: exception: '#{$!}'"
+        ensure
+          LibXML.xmlFreeDoc(ptr)
+          LibXML.xmlDeregisterNodeDefault(func)
+        end
+      end
+    end
+
+    #
+    #  use when we don't want to cause the doc to be GCed
+    #
+    class XmlDocumentCast < FFI::Struct # :nodoc:
+      include XmlDocumentMixin
+    end
+
+    HtmlDocument = XmlDocument # implemented identically in libxml2.6
+    HtmlDocumentCast = XmlDocumentCast # implemented identically in libxml2.6
+  end
+
+end

data/lib/nokogiri/ffi/structs/xml_dtd.rb

@@ -0,0 +1,26 @@
+module Nokogiri
+  module LibXML # :nodoc:
+    class XmlDtd < FFI::Struct # :nodoc:
+
+      layout(
+        :_private,      :long, # actually a pointer we're casting as an integer
+        :type,          :int,
+        :name,          :string,
+        :children,      :pointer,
+        :last,          :pointer,
+        :parent,        :pointer,
+        :next,          :pointer,
+        :prev,          :pointer,
+        :doc,           :pointer,
+
+        :notations,     :pointer,
+        :elements,      :pointer,
+        :attributes,    :pointer,
+        :entities,      :pointer
+        )
+
+      include CommonNode
+
+    end
+  end
+end

data/lib/nokogiri/ffi/structs/xml_node.rb

@@ -0,0 +1,28 @@
+module Nokogiri
+  module LibXML # :nodoc:
+    class XmlNode < FFI::Struct # :nodoc:
+
+      layout(
+        :_private,      :long, # actually a pointer we're casting as an integer
+        :type,          :int,
+        :name,          :string,
+        :children,      :pointer,
+        :last,          :pointer,
+        :parent,        :pointer,
+        :next,          :pointer,
+        :prev,          :pointer,
+        :doc,           :pointer,
+
+        :ns,            :pointer,
+        :content,       :string,
+        :properties,    :pointer,
+        :nsDef,         :pointer,
+        :psvi,          :pointer,
+        :line,          :short
+        )
+
+      include CommonNode
+
+    end
+  end
+end

data/lib/nokogiri/ffi/structs/xml_node_set.rb

@@ -0,0 +1,53 @@
+module Nokogiri
+  module LibXML # :nodoc:
+
+    module XmlNodeSetMixin # :nodoc:
+      def self.included(base)
+        base.class_eval do
+
+          layout(
+            :nodeNr,    :int,
+            :nodeMax,   :int,
+            :nodeTab,   :pointer
+            )
+
+        end
+      end
+
+      def document
+        p = self[:doc]
+        p.null? ? nil : LibXML::XmlDocumentCast.new(p)
+      end
+
+      def nodeAt(index)
+        self[:nodeTab].get_pointer(LibXML.pointer_offset(index))
+      end
+
+      def nodeTab
+        self[:nodeTab].read_array_of_pointer(self[:nodeNr])
+      end
+
+      def nodeTab=(array)
+        # TODO: do we need to check nodeMax and allocate more memory? probably.
+        self[:nodeTab].write_array_of_pointer(array)
+      end
+    end
+
+
+    class XmlNodeSet < FFI::ManagedStruct # :nodoc:
+      include XmlNodeSetMixin
+
+      def self.release ptr
+        ns = XmlNodeSetCast.new(ptr)
+        LibXML.xmlFree ns[:nodeTab] if ns[:nodeTab]
+        LibXML.xmlFree ptr
+      end
+    end
+
+
+    class XmlNodeSetCast < FFI::Struct # :nodoc:
+      include XmlNodeSetMixin
+    end
+
+  end
+end

data/lib/nokogiri/ffi/structs/xml_notation.rb

@@ -0,0 +1,11 @@
+module Nokogiri
+  module LibXML # :nodoc:
+    class XmlNotation < FFI::Struct # :nodoc:
+      layout(
+        :name,          :string,
+        :PublicID,      :string,
+        :SystemID,      :string
+        )
+    end
+  end
+end

data/lib/nokogiri/ffi/structs/xml_ns.rb

@@ -0,0 +1,15 @@
+module Nokogiri
+  module LibXML # :nodoc:
+    class XmlNs < FFI::Struct # :nodoc:
+      layout(
+        :next,     :pointer,
+        :type,     :int,
+        :href,     :string,
+        :prefix,   :string,
+        :_private, :long # actually a pointer we're casting as an integer
+        )
+
+      include CommonNode
+    end
+  end
+end

data/lib/nokogiri/ffi/structs/xml_relax_ng.rb

@@ -0,0 +1,14 @@
+module Nokogiri
+  module LibXML # :nodoc:
+    class XmlRelaxNG < FFI::ManagedStruct # :nodoc:
+
+      layout :dummy, :int, 0 # to avoid @layout warnings
+
+      def self.release ptr
+        LibXML.xmlRelaxNGFree(ptr)
+      end
+
+    end
+  end
+end
+

data/lib/nokogiri/ffi/structs/xml_sax_handler.rb

@@ -0,0 +1,51 @@
+module Nokogiri
+  module LibXML # :nodoc:
+    class XmlSaxHandler < FFI::ManagedStruct # :nodoc:
+
+      XML_SAX2_MAGIC = 0xDEEDBEAF # see, the libxml2 authors DO have a sense of humor. i think.
+
+      layout(:internalSubset,           :pointer,
+             :isStandalone,             :pointer,
+             :hasInternalSubset,        :pointer,
+             :hasExternalSubset,        :pointer,
+             :resolveEntity,            :pointer,
+             :getEntity,                :pointer,
+             :entityDecl,               :pointer,
+             :notationDecl,             :pointer,
+             :attributeDecl,            :pointer,
+             :elementDecl,              :pointer,
+             :unparsedEntityDecl,       :pointer,
+             :setDocumentLocator,       :pointer,
+             :startDocument,            :start_document_sax_func, 
+             :endDocument,              :end_document_sax_func ,
+             :startElement,             :start_element_sax_func,
+             :endElement,               :end_element_sax_func,
+             :reference,                :pointer,
+             :characters,               :characters_sax_func,
+             :ignorableWhitespace,      :pointer,
+             :processingInstruction,    :pointer,
+             :comment,                  :comment_sax_func,
+             :warning,                  :warning_sax_func, 
+             :error,                    :error_sax_func,
+             :fatalError,               :pointer,
+             :getParameterEntity,       :pointer,
+             :cdataBlock,               :cdata_block_sax_func, 
+             :externalSubset,           :pointer,
+             :initialized,              :uint,
+             :_private,                 :pointer,
+             :startElementNs,           :start_element_ns_sax2_func,
+             :endElementNs,             :end_element_ns_sax2_func,
+             :serror,                   :syntax_error_handler
+             )
+
+      def self.allocate
+        new LibXML.calloc(1, LibXML::XmlSaxHandler.size)
+      end
+
+      def self.release ptr
+        LibXML.free(ptr)
+      end
+
+    end
+  end
+end

data/lib/nokogiri/ffi/structs/xml_sax_push_parser_context.rb

@@ -0,0 +1,14 @@
+module Nokogiri
+  module LibXML # :nodoc:
+
+    class XmlSaxPushParserContext < FFI::ManagedStruct # :nodoc:
+
+      layout :dummy, :int, 0 # to avoid @layout warnings
+
+      def self.release ptr
+        LibXML.xmlFreeParserCtxt(ptr)
+      end
+    end
+
+  end
+end