nokogiri 1.2.3-x86-mswin32-60 → 1.4.5-x86-mswin32-60

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

@@ -0,0 +1,20 @@
+module Nokogiri
+  module LibXML # :nodoc:
+
+    class XmlXpathParserContext < FFI::Struct # :nodoc:
+
+      layout(
+        :cur,     :pointer,
+        :base,    :pointer,
+        :error,   :int,
+        :context, :pointer
+        )
+
+      def context
+        p = self[:context]
+        LibXML::XmlXpathContextCast.new(p)
+      end
+    end
+
+  end
+end

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

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

data/lib/nokogiri/ffi/weak_bucket.rb

@@ -0,0 +1,40 @@
+# :stopdoc:
+if ENV['NOKOGIRI_ID2REF'] || RUBY_PLATFORM !~ /java/
+  Nokogiri::VERSION_INFO['refs'] = "id2ref"
+else
+  require 'weakling'
+  Nokogiri::VERSION_INFO['refs'] = "weakling"
+end
+
+module Nokogiri
+  class WeakBucket
+    if Nokogiri::VERSION_INFO['refs'] == "weakling"
+      @@bucket = Weakling::IdHash.new
+      @@semaphore = Mutex.new
+
+      def WeakBucket.get_object(cstruct)
+        @@semaphore.synchronize do
+          @@bucket[cstruct.ruby_node_pointer]
+        end
+      end
+
+      def WeakBucket.set_object(cstruct, object)
+        @@semaphore.synchronize do
+          cstruct.ruby_node_pointer = @@bucket.add(object)
+        end
+      end
+
+    else
+
+      def WeakBucket.get_object(cstruct)
+        ptr = cstruct.ruby_node_pointer
+        ptr != 0 ? ObjectSpace._id2ref(ptr) : nil
+      end
+
+      def WeakBucket.set_object(cstruct, object)
+        cstruct.ruby_node_pointer = object.object_id
+      end
+    end
+  end
+end
+# :startdoc:

data/lib/nokogiri/ffi/xml/attr.rb

@@ -0,0 +1,41 @@
+module Nokogiri
+  module XML
+    class Attr < Node
+
+      def self.new(document, name, *rest) # :nodoc:
+        node_ptr = LibXML.xmlNewDocProp(document.cstruct, name.to_s, nil)
+        node_cstruct = LibXML::XmlNode.new(node_ptr)
+        node_cstruct.keep_reference_from_document!
+
+        node = Node.wrap(node_cstruct, self)
+        node.send :initialize, document, name, *rest
+        yield node if block_given?
+        node
+      end
+
+      def value=(content) # :nodoc:
+        unless cstruct[:children].null?
+          LibXML.xmlFreeNodeList(cstruct[:children])
+        end
+        cstruct[:children] = cstruct[:last] = nil
+        return unless content
+
+        char_ptr = LibXML.xmlEncodeEntitiesReentrant(cstruct[:doc], content)
+
+        cstruct[:children] = LibXML.xmlStringGetNodeList(cstruct[:doc], char_ptr)
+        child_cstruct = cstruct[:children]
+        while ! child_cstruct.null?
+          child = Node.wrap(child_cstruct)
+          child.cstruct[:parent] = cstruct
+          child.cstruct[:doc] = cstruct[:doc]
+          cstruct[:last] = child.cstruct
+          child_cstruct = child.cstruct[:next]
+        end
+        LibXML.xmlFree(char_ptr)
+
+        content
+      end
+
+    end
+  end
+end

data/lib/nokogiri/ffi/xml/attribute_decl.rb

@@ -0,0 +1,27 @@
+module Nokogiri
+  module XML
+    # :stopdoc:
+    class AttributeDecl < Nokogiri::XML::Node
+      def enumeration
+        list = []
+        return list if cstruct[:tree].null?
+        head = LibXML::XmlEnumeration.new cstruct[:tree]
+        loop do
+          list << head[:name]
+          break if head[:next].null?
+          head = LibXML::XmlEnumeration.new head[:next]
+        end
+        list
+      end
+
+      def attribute_type
+        cstruct[:atype]
+      end
+
+      def default
+        cstruct[:default_value]
+      end
+    end
+    # :startdoc:
+  end
+end

data/lib/nokogiri/ffi/xml/cdata.rb

@@ -0,0 +1,19 @@
+module Nokogiri
+  module XML
+    class CDATA < Text
+      
+      def self.new(document, content, *rest) # :nodoc:
+        length = content.nil? ? 0 : content.length
+        node_ptr = LibXML.xmlNewCDataBlock(document.cstruct[:doc], content, length)
+        node_cstruct = LibXML::XmlNode.new(node_ptr)
+        node_cstruct.keep_reference_from_document!
+
+        node = Node.wrap(node_cstruct, self)
+        node.send :initialize, document, content, *rest
+        yield node if block_given?
+        node
+      end
+
+    end
+  end
+end

data/lib/nokogiri/ffi/xml/comment.rb

@@ -0,0 +1,18 @@
+module Nokogiri
+  module XML
+    class Comment < CharacterData
+
+      def self.new(document, content, *rest) # :nodoc:
+        node_ptr = LibXML.xmlNewDocComment(document.cstruct, content)
+        node_cstruct = LibXML::XmlNode.new(node_ptr)
+        node_cstruct.keep_reference_from_document!
+
+        node = Node.wrap(node_ptr, self)
+        node.send :initialize, document, content, *rest
+        yield node if block_given?
+        node
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,174 @@
+# :stopdoc:
+module Nokogiri
+  module XML
+    class Document < Node
+
+      attr_accessor :cstruct
+
+      def url
+        cstruct[:URL]
+      end
+
+      def root= new_root
+        old_root = nil
+
+        if new_root.nil?
+          old_root_ptr = LibXML.xmlDocGetRootElement(cstruct)
+          if (! old_root_ptr.null?)
+            old_root = Node.wrap(old_root_ptr)
+            LibXML.xmlUnlinkNode(old_root.cstruct)
+            old_root.cstruct.keep_reference_from_document!
+          end
+          return new_root
+        end
+
+        if new_root.cstruct[:doc] != cstruct[:doc]
+          old_root_ptr = LibXML.xmlDocGetRootElement(cstruct)
+          new_root_ptr = LibXML.xmlDocCopyNode(new_root.cstruct, cstruct, 1)
+          raise RuntimeError "Could not reparent node (xmlDocCopyNode)" if new_root_ptr.null?
+          new_root = Node.wrap(new_root_ptr)
+        end
+        LibXML.xmlDocSetRootElement(cstruct, new_root.cstruct)
+        if old_root_ptr && ! old_root_ptr.null?
+          LibXML::XmlNode.new(old_root_ptr).keep_reference_from_document!
+        end
+        new_root
+      end
+
+      def root
+        ptr = LibXML.xmlDocGetRootElement(cstruct)
+        ptr.null? ? nil : Node.wrap(LibXML::XmlNode.new(ptr))
+      end
+
+      def encoding= encoding
+        # TODO: if :encoding is already set, then it's probably getting leaked.
+        cstruct[:encoding] = LibXML.xmlStrdup(encoding)
+      end
+
+      def encoding
+        ptr = cstruct[:encoding]
+        ptr.null? ? nil : ptr.read_string
+      end
+
+      def version
+        cstruct[:version]
+      end
+
+      def self.read_io io, url, encoding, options
+        wrap_with_error_handling do
+          LibXML.xmlReadIO(IoCallbacks.reader(io), nil, nil, url, encoding, options)
+        end
+      end
+
+      def self.read_memory(string, url, encoding, options)
+        wrap_with_error_handling do
+          LibXML.xmlReadMemory(string, string.length, url, encoding, options)
+        end
+      end
+
+      def dup deep = 1
+        dup_ptr = LibXML.xmlCopyDoc(cstruct, deep)
+        return nil if dup_ptr.null?
+
+        # xmlCopyDoc does not preserve document type. wtf?
+        cstruct = LibXML::XmlDocumentCast.new(dup_ptr)
+        cstruct[:type] = self.type
+
+        self.class.wrap(dup_ptr)
+      end
+
+      def remove_namespaces!
+        self.class.recursively_remove_namespaces_from_node(root)
+      end
+
+      def create_entity(name, entity_type=Nokogiri::XML::EntityDecl::INTERNAL_GENERAL,
+                        external_id=nil, system_id=nil, content=nil)
+        LibXML.xmlResetLastError()
+        ptr = LibXML.xmlAddDocEntity(cstruct, name, entity_type, external_id, system_id, content)
+        if ptr.null?
+          error = LibXML.xmlGetLastError()
+          if error
+            raise SyntaxError.wrap(error)
+          else
+            raise RuntimeError, "Could not create entity"
+          end
+        end
+
+        Node.wrap(LibXML::XmlEntity.new(ptr))
+      end
+
+      class << self
+        def new(*args)
+          version = args.first || "1.0"
+          doc = wrap(LibXML.xmlNewDoc(version))
+          doc.send :initialize, *args
+          doc
+        end
+
+        def wrap doc_struct
+          if doc_struct.is_a?(FFI::Pointer)
+            # cast native pointers up into a doc cstruct
+            return nil if doc_struct.null?
+            doc_struct = LibXML::XmlDocument.new(doc_struct)
+          end
+
+          doc                  = self.allocate
+          doc.cstruct          = doc_struct
+          doc.cstruct.ruby_doc = doc
+          doc.instance_eval { @decorators = nil; @node_cache = [] }
+          doc.send :initialize
+          doc
+        end
+      end
+
+      private
+
+      class << self
+        def wrap_with_error_handling(&block)
+          error_list = []
+          LibXML.xmlInitParser()
+          LibXML.xmlResetLastError()
+          LibXML.xmlSetStructuredErrorFunc(nil, SyntaxError.error_array_pusher(error_list))
+
+          ptr = yield
+
+          LibXML.xmlSetStructuredErrorFunc(nil, nil)
+
+          if ptr.null?
+            error = LibXML.xmlGetLastError()
+            if error
+              raise SyntaxError.wrap(error)
+            else
+              raise RuntimeError, "Could not parse document"
+            end
+          end
+
+          document = wrap(ptr)
+          document.errors = error_list
+          return document
+        end
+
+        def recursively_remove_namespaces_from_node(node)
+          node.cstruct[:ns] = nil
+          node.children.each do |child|
+            recursively_remove_namespaces_from_node(child)
+          end
+          unless node.cstruct[:nsDef].nil?
+            LibXML.xmlFreeNsList(node.cstruct[:nsDef])
+            node.cstruct[:nsDef] = nil
+          end
+          unless node.cstruct[:properties].nil?
+            prop_ptr = node.cstruct[:properties]
+            while ! prop_ptr.null?
+              prop_cstruct = LibXML::XmlAttr.new(node.cstruct[:properties])
+              prop_cstruct[:ns] = nil unless prop_cstruct[:ns].nil?
+              prop_ptr = prop_cstruct[:next]
+            end
+          end
+        end
+      end
+
+    end
+  end
+end
+# :startdoc:

data/lib/nokogiri/ffi/xml/document_fragment.rb

@@ -0,0 +1,21 @@
+module Nokogiri
+  module XML
+    class DocumentFragment < Node
+
+      def self.new(document, *rest) # :nodoc:
+        node_ptr = LibXML.xmlNewDocFragment(document.cstruct)
+        node_cstruct = LibXML::XmlNode.new(node_ptr)
+        node_cstruct.keep_reference_from_document!
+
+        node = Node.wrap(node_cstruct, self)
+
+        node.send :initialize, document, *rest
+        yield node if block_given?
+
+        node
+      end
+
+    end
+  end
+end
+

data/lib/nokogiri/ffi/xml/dtd.rb

@@ -0,0 +1,67 @@
+# :stopdoc:
+module Nokogiri
+  module XML
+    class DTD < Node
+      def validate document
+        error_list = []
+        ctxt = LibXML.xmlNewValidCtxt
+
+        LibXML.xmlSetStructuredErrorFunc(nil, SyntaxError.error_array_pusher(error_list))
+        LibXML.xmlValidateDtd ctxt, document.cstruct, cstruct
+
+        LibXML.xmlSetStructuredErrorFunc nil, nil
+
+        LibXML.xmlFreeValidCtxt ctxt
+
+        error_list
+      end
+
+      def system_id
+        cstruct[:system_id]
+      end
+
+      def external_id
+        cstruct[:external_id]
+      end
+
+      def elements
+        internal_attributes :elements
+      end
+
+      def entities
+        internal_attributes :entities
+      end
+
+      def attributes
+        internal_attributes :attributes
+      end
+
+      def notations
+        attr_ptr = cstruct[:notations]
+        return nil if attr_ptr.null?
+
+        ahash = {}
+        LibXML.xmlHashScan(attr_ptr, nil) do |payload, data, name|
+          notation_cstruct = LibXML::XmlNotation.new(payload)
+          ahash[name] = Notation.new(notation_cstruct[:name], notation_cstruct[:PublicID],
+                                     notation_cstruct[:SystemID])
+        end
+        ahash
+      end
+
+      private
+
+      def internal_attributes attr_name
+        attr_ptr = cstruct[attr_name.to_sym]
+        ahash = {}
+        return ahash if attr_ptr.null?
+
+        LibXML.xmlHashScan(attr_ptr, nil) do |payload, data, name|
+          ahash[name] = Node.wrap(payload)
+        end
+        ahash
+      end
+    end
+  end
+end
+# :startdoc: