caring-nokogiri 1.4.1.pre1

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

@@ -0,0 +1,133 @@
+module Nokogiri
+  module XML
+    class NodeSet
+
+      attr_accessor :cstruct # :nodoc:
+
+      def dup # :nodoc:
+        dup = LibXML.xmlXPathNodeSetMerge(nil, self.cstruct)
+        NodeSet.wrap(dup)
+      end
+
+      def length # :nodoc:
+        cstruct.pointer.null? ? 0 : cstruct[:nodeNr]
+      end
+
+      def push(node) # :nodoc:
+        raise(ArgumentError, "node must be a Nokogiri::XML::Node") unless node.is_a?(XML::Node)
+        LibXML.xmlXPathNodeSetAdd(cstruct, node.cstruct)
+        self
+      end
+
+      def |(node_set) # :nodoc:
+        raise(ArgumentError, "node_set must be a Nokogiri::XML::NodeSet") unless node_set.is_a?(XML::NodeSet)
+        new_set_ptr = LibXML::xmlXPathNodeSetMerge(nil, self.cstruct)
+        new_set_ptr = LibXML::xmlXPathNodeSetMerge(new_set_ptr, node_set.cstruct)
+
+        new_set = NodeSet.wrap(new_set_ptr)
+        new_set.document = document
+        new_set
+      end
+
+      def -(node_set) # :nodoc:
+        raise(ArgumentError, "node_set must be a Nokogiri::XML::NodeSet") unless node_set.is_a?(XML::NodeSet)
+        new_set_ptr = LibXML.xmlXPathNodeSetMerge(nil, self.cstruct)
+
+        other_nodetab = node_set.cstruct.nodeTab
+        node_set.cstruct[:nodeNr].times do |j|
+          LibXML.xmlXPathNodeSetDel(new_set_ptr, other_nodetab[j])
+        end        
+        NodeSet.wrap(new_set_ptr)
+      end
+
+      def delete(node) # :nodoc:
+        raise(ArgumentError, "node must be a Nokogiri::XML::Node") unless node.is_a?(XML::Node)
+        if LibXML.xmlXPathNodeSetContains(cstruct, node.cstruct) != 0
+          LibXML.xmlXPathNodeSetDel(cstruct, node.cstruct)
+          return node
+        end
+        return nil
+      end
+
+      def [](*args) # :nodoc:
+        raise(ArgumentError, "got #{args.length} arguments, expected 1 (or 2)") if args.length > 2
+
+        if args.length == 2
+          beg = args[0]
+          len = args[1]
+          beg += cstruct[:nodeNr] if beg < 0
+          return subseq(beg, len)
+        end
+        arg = args[0]
+
+        return subseq(arg.first, arg.last-arg.first+1) if arg.is_a?(Range)
+
+        index_at(arg)
+      end
+      alias_method :slice, :[]
+
+      def &(node_set) # :nodoc:
+        raise(ArgumentError, "node_set must be a Nokogiri::XML::NodeSet") unless node_set.is_a?(XML::NodeSet)
+        new_set_ptr = LibXML.xmlXPathIntersection(cstruct, node_set.cstruct)
+        NodeSet.wrap(new_set_ptr)
+      end
+
+      def include?(node) # :nodoc:
+        raise(ArgumentError, "node must be a Nokogiri::XML::Node") unless node.is_a?(XML::Node)
+        (LibXML.xmlXPathNodeSetContains(cstruct, node.cstruct) != 0) ? true : false
+      end
+
+      def to_a # :nodoc:
+        cstruct.nodeTab.collect { |node| Node.wrap(node) }
+      end
+
+      def unlink # :nodoc:
+        # TODO: is this simpler implementation viable:
+        #  cstruct.nodeTab.collect {|node| Node.wrap(node)}.each(&:unlink)
+        # ?
+        nodetab = cstruct.nodeTab
+        cstruct[:nodeNr].times do |j|
+          node = Node.wrap(nodetab[j])
+          node.unlink
+          nodetab[j] = node.cstruct.pointer
+        end
+        cstruct.nodeTab = nodetab
+        self
+      end
+
+      def self.new document, list = [] # :nodoc:
+        set = NodeSet.wrap(LibXML.xmlXPathNodeSetCreate(nil))
+        set.document = document
+        list.each { |x| set << x }
+        yield set if block_given?
+        set
+      end
+
+      private
+
+      def self.wrap(ptr) # :nodoc:
+        set = allocate
+        set.cstruct = LibXML::XmlNodeSet.new(ptr)
+        set
+      end
+
+      def index_at(number) # :nodoc:
+        return nil if (number >= cstruct[:nodeNr] || number.abs > cstruct[:nodeNr])
+        number = number + cstruct[:nodeNr] if number < 0
+        Node.wrap(cstruct.nodeAt(number))
+      end
+
+      def subseq(beg, len) # :nodoc:
+        return nil if beg > cstruct[:nodeNr]
+        return nil if beg < 0 || len < 0
+
+        set = NodeSet.wrap(LibXML.xmlXPathNodeSetCreate(nil))
+        beg.upto(beg+len-1) do |j|
+          LibXML.xmlXPathNodeSetAdd(set.cstruct, cstruct.nodeAt(j));
+        end
+        set
+      end
+
+    end
+  end
+end

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

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

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

@@ -0,0 +1,227 @@
+# :stopdoc:
+module Nokogiri
+  module XML
+    class Reader
+
+      attr_accessor :cstruct
+      attr_accessor :reader_callback
+
+      def default?
+        LibXML.xmlTextReaderIsDefault(cstruct) == 1
+      end
+
+      def value?
+        LibXML.xmlTextReaderHasValue(cstruct) == 1
+      end
+
+      def attributes?
+        #  this implementation of xmlTextReaderHasAttributes explicitly includes
+        #  namespaces and properties, because some earlier versions ignore
+        #  namespaces.
+        node_ptr = LibXML.xmlTextReaderCurrentNode(cstruct)
+        return false if node_ptr.null?
+        node = LibXML::XmlNode.new node_ptr
+        node[:type] == Node::ELEMENT_NODE && (!node[:properties].null? || !node[:nsDef].null?)
+      end
+
+      def namespaces
+        return {} unless attributes?
+
+        ptr = LibXML.xmlTextReaderExpand(cstruct)
+        return nil if ptr.null?
+
+        Reader.node_namespaces(ptr)
+      end
+
+      def attr_nodes
+        return {} unless attributes?
+
+        ptr = LibXML.xmlTextReaderExpand(cstruct)
+        return nil if ptr.null?
+        node_struct = LibXML::XmlNode.new(ptr)
+
+        Node.node_properties node_struct
+      end
+
+      def attribute_at(index)
+        return nil if index.nil?
+        index = index.to_i
+        attr_ptr = LibXML.xmlTextReaderGetAttributeNo(cstruct, index)
+        return nil if attr_ptr.null?
+
+        attr = attr_ptr.read_string
+        LibXML.xmlFree attr_ptr
+        attr
+      end
+
+      def attribute(name)
+        return nil if name.nil?
+        attr_ptr = LibXML.xmlTextReaderGetAttribute(cstruct, name.to_s)
+        if attr_ptr.null?
+          # this section is an attempt to workaround older versions of libxml that
+          # don't handle namespaces properly in all attribute-and-friends functions
+          prefix_ptr = FFI::MemoryPointer.new :pointer
+          localname = LibXML.xmlSplitQName2(name, prefix_ptr)
+          prefix = prefix_ptr.get_pointer(0)
+          if ! localname.null?
+            attr_ptr = LibXML.xmlTextReaderLookupNamespace(cstruct, localname.read_string)
+            LibXML.xmlFree(localname)
+          else
+            if prefix.null? || prefix.read_string.length == 0
+              attr_ptr = LibXML.xmlTextReaderLookupNamespace(cstruct, nil)
+            else
+              attr_ptr = LibXML.xmlTextReaderLookupNamespace(cstruct, prefix.read_string)
+            end
+          end
+          LibXML.xmlFree(prefix)
+        end
+        return nil if attr_ptr.null?
+
+        attr = attr_ptr.read_string
+        LibXML.xmlFree(attr_ptr)
+        attr
+      end
+
+      def attribute_count
+        count = LibXML.xmlTextReaderAttributeCount(cstruct)
+        count == -1 ? nil : count
+      end
+
+      def depth
+        val = LibXML.xmlTextReaderDepth(cstruct)
+        val == -1 ? nil : val
+      end
+
+      def xml_version
+        val = LibXML.xmlTextReaderConstXmlVersion(cstruct)
+        val.null? ? nil : val.read_string
+      end
+
+      def lang
+        val = LibXML.xmlTextReaderConstXmlLang(cstruct)
+        val.null? ? nil : val.read_string
+      end
+
+      def value
+        val = LibXML.xmlTextReaderConstValue(cstruct)
+        val.null? ? nil : val.read_string
+      end
+
+      def prefix
+        val = LibXML.xmlTextReaderConstPrefix(cstruct)
+        val.null? ? nil : val.read_string
+      end
+
+      def namespace_uri
+        val = LibXML.xmlTextReaderConstNamespaceUri(cstruct)
+        val.null? ? nil : val.read_string
+      end
+
+      def local_name
+        val = LibXML.xmlTextReaderConstLocalName(cstruct)
+        val.null? ? nil : val.read_string
+      end
+
+      def name
+        val = LibXML.xmlTextReaderConstName(cstruct)
+        val.null? ? nil : val.read_string
+      end
+
+      def state
+        LibXML.xmlTextReaderReadState(cstruct)
+      end
+
+      def read
+        error_list = self.errors
+
+        LibXML.xmlSetStructuredErrorFunc(nil, SyntaxError.error_array_pusher(error_list))
+        ret = LibXML.xmlTextReaderRead(cstruct)
+        LibXML.xmlSetStructuredErrorFunc(nil, nil)
+
+        return self if ret == 1
+        return nil if ret == 0
+
+        error = LibXML.xmlGetLastError()
+        if error
+          raise SyntaxError.wrap(error)
+        else
+          raise RuntimeError, "Error pulling: #{ret}"
+        end
+
+        nil
+      end
+
+      def inner_xml
+        string_ptr = LibXML.xmlTextReaderReadInnerXml(cstruct)
+        return nil if string_ptr.null?
+        string = string_ptr.read_string
+        LibXML.xmlFree(string_ptr)
+        string
+      end
+
+      def outer_xml
+        string_ptr = LibXML.xmlTextReaderReadOuterXml(cstruct)
+        return nil if string_ptr.null?
+        string = string_ptr.read_string
+        LibXML.xmlFree(string_ptr)
+        string
+      end
+
+      def node_type
+        LibXML.xmlTextReaderNodeType(cstruct)
+      end
+
+      def self.from_memory(buffer, url=nil, encoding=nil, options=0)
+        raise(ArgumentError, "string cannot be nil") if buffer.nil?
+
+        memory = FFI::MemoryPointer.new(buffer.length) # we need to manage native memory lifecycle
+        memory.put_bytes(0, buffer)
+        reader_ptr = LibXML.xmlReaderForMemory(memory, memory.total, url, encoding, options)
+        raise(RuntimeError, "couldn't create a reader") if reader_ptr.null?
+
+        reader = allocate
+        reader.cstruct = LibXML::XmlTextReader.new(reader_ptr)
+        reader.send(:initialize, memory, url, encoding)
+        reader
+      end
+
+      def self.from_io(io, url=nil, encoding=nil, options=0)
+        raise(ArgumentError, "io cannot be nil") if io.nil?
+
+        cb = IoCallbacks.reader(io) # we will keep a reference to prevent it from being GC'd
+        reader_ptr = LibXML.xmlReaderForIO(cb, nil, nil, url, encoding, options)
+        raise "couldn't create a parser" if reader_ptr.null?
+
+        reader = allocate
+        reader.cstruct = LibXML::XmlTextReader.new(reader_ptr)
+        reader.send(:initialize, io, url, encoding)
+        reader.reader_callback = cb
+        reader
+      end
+
+      private
+
+      class << self
+        def node_namespaces(ptr)
+          cstruct = LibXML::XmlNode.new(ptr)
+          ahash = {}
+          return ahash unless cstruct[:type] == Node::ELEMENT_NODE
+          ns = cstruct[:nsDef]
+          while ! ns.null?
+            ns_cstruct = LibXML::XmlNs.new(ns)
+            prefix = ns_cstruct[:prefix]
+            key = if prefix.nil? || prefix.empty?
+                    "xmlns"
+                  else
+                    "xmlns:#{prefix}"
+                  end
+            ahash[key] = ns_cstruct[:href] # TODO: encoding?
+            ns = ns_cstruct[:next] # TODO: encoding?
+          end
+          ahash
+        end
+      end
+    end
+  end
+end
+# :startdoc:

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

@@ -0,0 +1,85 @@
+module Nokogiri
+  module XML
+    class RelaxNG < Schema
+      # :stopdoc:
+      def validate_document document
+        errors = []
+
+        ctx = LibXML.xmlRelaxNGNewValidCtxt(cstruct)
+        raise RuntimeError.new("Could not create a validation context") if ctx.null?
+
+        LibXML.xmlRelaxNGSetValidStructuredErrors(ctx,
+          SyntaxError.error_array_pusher(errors), nil) unless Nokogiri.is_2_6_16?
+
+        LibXML.xmlRelaxNGValidateDoc(ctx, document.cstruct)
+
+        LibXML.xmlRelaxNGFreeValidCtxt(ctx)
+
+        errors
+      end
+      private :validate_document
+
+      def self.read_memory content
+        content_copy = FFI::MemoryPointer.from_string(content)
+        ctx = LibXML.xmlRelaxNGNewMemParserCtxt(content_copy, content.length)
+
+        errors = []
+
+        LibXML.xmlSetStructuredErrorFunc(nil, SyntaxError.error_array_pusher(errors))
+        LibXML.xmlRelaxNGSetParserStructuredErrors(
+          ctx, SyntaxError.error_array_pusher(errors), nil) unless Nokogiri.is_2_6_16?
+
+        schema_ptr = LibXML.xmlRelaxNGParse(ctx)
+
+        LibXML.xmlSetStructuredErrorFunc(nil, nil)
+        LibXML.xmlRelaxNGFreeParserCtxt(ctx)
+
+        if schema_ptr.null?
+          error = LibXML.xmlGetLastError
+          if error
+            raise SyntaxError.wrap(error)
+          else
+            raise RuntimeError, "Could not parse document"
+          end
+        end
+
+        schema = allocate
+        schema.cstruct = LibXML::XmlRelaxNG.new schema_ptr
+        schema.errors = errors
+        schema
+      end
+
+      def self.from_document document
+        ctx = LibXML.xmlRelaxNGNewDocParserCtxt document.document.cstruct
+
+        errors = []
+
+        LibXML.xmlSetStructuredErrorFunc(nil, SyntaxError.error_array_pusher(errors))
+        LibXML.xmlRelaxNGSetParserStructuredErrors(
+          ctx, SyntaxError.error_array_pusher(errors), nil) unless Nokogiri.is_2_6_16?
+
+        schema_ptr = LibXML.xmlRelaxNGParse(ctx)
+
+        LibXML.xmlSetStructuredErrorFunc(nil, nil)
+        LibXML.xmlRelaxNGFreeParserCtxt(ctx) unless Nokogiri.is_2_6_16?
+
+        if schema_ptr.null?
+          error = LibXML.xmlGetLastError
+          if error
+            raise SyntaxError.wrap(error)
+          else
+            raise RuntimeError, "Could not parse document"
+          end
+        end
+
+        LibXML.xmlRelaxNGFreeParserCtxt(ctx) if Nokogiri.is_2_6_16?
+
+        schema = allocate
+        schema.cstruct = LibXML::XmlRelaxNG.new schema_ptr
+        schema.errors = errors
+        schema
+      end
+      # :startdoc:
+    end
+  end
+end