nokogiri 1.3.0-x86-mswin32

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,217 @@
+module Nokogiri
+  module XML
+    class Reader
+
+      attr_accessor :cstruct # :nodoc:
+      attr_accessor :reader_callback # :nodoc:
+
+      def default? # :nodoc:
+        LibXML.xmlTextReaderIsDefault(cstruct) == 1
+      end
+
+      def value? # :nodoc:
+        LibXML.xmlTextReaderHasValue(cstruct) == 1
+      end
+
+      def attributes? # :nodoc:
+        #  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 # :nodoc:
+        return {} unless attributes?
+
+        ptr = LibXML.xmlTextReaderExpand(cstruct)
+        return nil if ptr.null?
+
+        node = Node.wrap(ptr)
+        Reader.node_namespaces(node)
+      end
+
+      def attribute_nodes # :nodoc:
+        return {} unless attributes?
+
+        ptr = LibXML.xmlTextReaderExpand(cstruct)
+        return nil if ptr.null?
+        node_struct = LibXML::XmlNode.new(ptr)
+
+        # FIXME I'm not sure if this is correct.....  I don't really like pointing
+        # at this document, but I have to because of the assertions in
+        # the node wrapping code.
+        unless node_struct.document.ruby_doc
+          doc_struct = LibXML::XmlDocumentCast.new(node_struct[:doc])
+          doc_struct.alloc_tuple
+          doc = Document.wrap(doc_struct)
+        end
+
+        node = Node.wrap(node_struct)
+        node.attribute_nodes
+      end
+
+      def attribute_at(index) # :nodoc:
+        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) # :nodoc:
+        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 # :nodoc:
+        count = LibXML.xmlTextReaderAttributeCount(cstruct)
+        count == -1 ? nil : count
+      end
+
+      def depth # :nodoc:
+        val = LibXML.xmlTextReaderDepth(cstruct)
+        val == -1 ? nil : val
+      end
+
+      def xml_version # :nodoc:
+        val = LibXML.xmlTextReaderConstXmlVersion(cstruct)
+        val.null? ? nil : val.read_string
+      end
+
+      def lang # :nodoc:
+        val = LibXML.xmlTextReaderConstXmlLang(cstruct)
+        val.null? ? nil : val.read_string
+      end
+
+      def value # :nodoc:
+        val = LibXML.xmlTextReaderConstValue(cstruct)
+        val.null? ? nil : val.read_string
+      end
+
+      def prefix # :nodoc:
+        val = LibXML.xmlTextReaderConstPrefix(cstruct)
+        val.null? ? nil : val.read_string
+      end
+
+      def namespace_uri # :nodoc:
+        val = LibXML.xmlTextReaderConstNamespaceUri(cstruct)
+        val.null? ? nil : val.read_string
+      end
+
+      def local_name # :nodoc:
+        val = LibXML.xmlTextReaderConstLocalName(cstruct)
+        val.null? ? nil : val.read_string
+      end
+
+      def name # :nodoc:
+        val = LibXML.xmlTextReaderConstName(cstruct)
+        val.null? ? nil : val.read_string
+      end
+
+      def state # :nodoc:
+        LibXML.xmlTextReaderReadState(cstruct)
+      end
+
+      def read # :nodoc:
+        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 self.from_memory(buffer, url=nil, encoding=nil, options=0) # :nodoc:
+        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) # :nodoc:
+        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(node) # :nodoc:
+          cstruct = node.cstruct
+          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

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

@@ -0,0 +1,51 @@
+module Nokogiri
+  module XML
+    class RelaxNG < Schema
+      def validate_document(document) # :nodoc:
+        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) # :nodoc:
+        ctx = LibXML.xmlRelaxNGNewMemParserCtxt(content, 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
+    end
+  end
+end

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

@@ -0,0 +1,148 @@
+module Nokogiri
+  module XML
+    module SAX
+      class Parser
+        
+        attr_accessor :cstruct # :nodoc:
+
+        def parse_memory(data) # :nodoc:
+          raise(ArgumentError, 'data cannot be nil') if data.nil?
+          LibXML.xmlSAXUserParseMemory(cstruct, nil, data, data.length)
+          data
+        end
+
+        def native_parse_io(io, encoding) # :nodoc:
+          sax_ctx = LibXML.xmlCreateIOParserCtxt(cstruct, nil, IoCallbacks.reader(io), nil, nil, encoding)
+          LibXML.xmlParseDocument(sax_ctx)
+          LibXML.xmlFreeParserCtxt(sax_ctx)
+          io
+        end
+
+        def native_parse_file(data) # :nodoc:
+          LibXML.xmlSAXUserParseFile(cstruct, nil, data)
+        end
+
+        def self.new(doc = XML::SAX::Document.new, encoding = 'ASCII') # :nodoc:
+          parser = allocate
+          parser.document = doc
+          parser.encoding = encoding
+          parser.cstruct = LibXML::XmlSaxHandler.allocate
+          parser.send(:setup_lambdas)
+          parser
+        end
+
+      private
+
+        def setup_lambdas # :nodoc:
+          @closures = {} # we need to keep references to the closures to avoid GC
+          
+          [ :startDocument, :endDocument, :startElement, :endElement, :characters,
+            :comment, :warning, :error, :cdataBlock, :startElementNs, :endElementNs ].each do |sym|
+            @closures[sym] = lambda { |*args| send("__internal__#{sym}", *args) } # "i'm your private dancer", etc.
+          end
+
+          @closures.each { |k,v| cstruct[k] = v }
+
+          cstruct[:initialized] = Nokogiri::LibXML::XmlSaxHandler::XML_SAX2_MAGIC
+        end
+
+        def __internal__startDocument(_) # :nodoc:
+          @document.start_document
+        end
+
+        def __internal__endDocument(_) # :nodoc:
+          @document.end_document
+        end
+
+        def __internal__startElement(_, name, attributes) # :nodoc:
+          attrs = []
+          unless attributes.null?
+            j = 0
+            while ! (value = attributes.get_pointer(LibXML.pointer_offset(j))).null?
+              attrs << value.read_string
+              j += 1
+            end
+          end
+          @document.start_element name, attrs
+        end
+
+        def __internal__endElement(_, name) # :nodoc:
+          @document.end_element name
+        end
+
+        def __internal__characters(_, data, data_length) # :nodoc:
+          @document.characters data.slice(0, data_length)
+        end
+
+        def __internal__comment(_, data) # :nodoc:
+          @document.comment data
+        end
+
+        def __internal__warning(_, msg) # :nodoc:
+          # TODO: vasprintf here
+          @document.warning(msg)
+        end
+
+        def __internal__error(_, msg) # :nodoc:
+          # TODO: vasprintf here
+          @document.error(msg)
+        end
+
+        def __internal__cdataBlock(_, data, data_length) # :nodoc:
+          @document.cdata_block data.slice(0, data_length)
+        end
+
+        def __internal__startElementNs(_, localname, prefix, uri, nb_namespaces, namespaces, nb_attributes, nb_defaulted, attributes) # :nodoc:
+          localname = localname.null? ? nil : localname.read_string
+          prefix    = prefix   .null? ? nil : prefix   .read_string
+          uri       = uri      .null? ? nil : uri      .read_string
+
+          attr_hash = {}
+          ns_hash   = {}
+
+          if ! attributes.null?
+            # Each attribute is an array of [localname, prefix, URI, value, end]
+            (0..(nb_attributes-1)*5).step(5) do |j|
+              key          = attributes.get_pointer(LibXML.pointer_offset(j)).read_string
+              value_length = attributes.get_pointer(LibXML.pointer_offset(j+4)).address \
+                           - attributes.get_pointer(LibXML.pointer_offset(j+3)).address
+              value        = attributes.get_pointer(LibXML.pointer_offset(j+3)).get_string(0, value_length)
+              attr_hash[key] = value
+            end
+          end
+
+          if ! namespaces.null?
+            (0..(nb_namespaces-1)*2).step(2) do |j|
+              key   = namespaces.get_pointer(LibXML.pointer_offset(j))
+              key   = key.null?   ? nil : key.read_string
+              value = namespaces.get_pointer(LibXML.pointer_offset(j+1))
+              value = value.null? ? nil : value.read_string
+              ns_hash[key] = value
+            end
+          end
+
+          @document.start_element_ns(localname, attr_hash, prefix, uri, ns_hash)
+
+          if @document.respond_to?(:start_element)
+            name = prefix ? "#{prefix}:#{localname}" : localname
+            @document.start_element(name, attr_hash.to_a.flatten)
+          end
+        end
+
+        def __internal__endElementNs(_, localname, prefix, uri) # :nodoc:
+          localname = localname.null? ? nil : localname.read_string
+          prefix    = prefix   .null? ? nil : prefix   .read_string
+          uri       = uri      .null? ? nil : uri      .read_string
+
+          @document.end_element_ns(localname, prefix, uri)
+
+          if @document.respond_to?(:end_element)
+            name = prefix ? "#{prefix}:#{localname}" : localname
+            @document.end_element(name)
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/nokogiri/ffi/xml/sax/push_parser.rb

@@ -0,0 +1,38 @@
+module Nokogiri
+  module XML
+    module SAX
+      class PushParser
+
+        attr_accessor :cstruct # :nodoc:
+
+        private
+
+        def native_write(chunk, last_chunk) # :nodoc:
+          size = 0
+          unless chunk.nil?
+            chunk = chunk.to_s
+            size = chunk.length
+          end
+
+          last_chunk = last_chunk ? 1 : 0
+
+          rcode = LibXML.xmlParseChunk(cstruct, chunk, size, last_chunk)
+          raise RuntimeError, "Couldn't parse chunk" if 0 != rcode
+
+          self
+        end
+
+        def initialize_native(sax, filename) # :nodoc:
+          filename = filename.to_s unless filename.nil?
+          ctx_ptr = LibXML.xmlCreatePushParserCtxt(
+            sax.cstruct, nil, nil, 0, filename
+            )
+          raise(RuntimeError, "Could not create a parser context") if ctx_ptr.null?
+          self.cstruct = LibXML::XmlSaxPushParserContext.new(ctx_ptr) ;
+          self
+        end
+
+      end
+    end
+  end
+end