nokogiri 1.4.7 → 1.5.0.beta.1

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

@@ -1,20 +0,0 @@
-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

@@ -1,13 +0,0 @@
-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

@@ -1,40 +0,0 @@
-# :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

@@ -1,41 +0,0 @@
-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

@@ -1,27 +0,0 @@
-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

@@ -1,19 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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

@@ -1,174 +0,0 @@
-# :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

@@ -1,21 +0,0 @@
-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

@@ -1,67 +0,0 @@
-# :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: