nokogiri 1.4.7-x86-mingw32 → 1.5.0-x86-mingw32

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

@@ -1,150 +0,0 @@
-module Nokogiri
-  module XML
-    class NodeSet
-
-      attr_accessor :cstruct # :nodoc:
-
-      def dup # :nodoc:
-        dup = LibXML.xmlXPathNodeSetMerge(nil, self.cstruct)
-        NodeSet.wrap(dup, self.document)
-      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) || node.is_a?(XML::Namespace)
-        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)
-
-        NodeSet.wrap(new_set_ptr, self.document)
-      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, self.document)
-      end
-
-      def delete(node) # :nodoc:
-        raise(ArgumentError, "node must be a Nokogiri::XML::Node") unless node.is_a?(XML::Node) || node.is_a?(XML::Namespace)
-        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, self.document)
-      end
-
-      def include?(node) # :nodoc:
-        raise(ArgumentError, "node must be a Nokogiri::XML::Node") unless node.is_a?(XML::Node) || node.is_a?(XML::Namespace)
-        (LibXML.xmlXPathNodeSetContains(cstruct, node.cstruct) != 0) ? true : false
-      end
-
-      def to_a # :nodoc:
-        cstruct.nodeTab.collect do |node|
-          node_cstruct = LibXML::XmlNode.new(node)
-          if node_cstruct[:type] == XML::Node::NAMESPACE_DECL
-            Namespace.wrap(document.cstruct, node)
-          else
-            Node.wrap(node_cstruct)
-          end
-        end
-      end
-
-      def unlink # :nodoc:
-        return if cstruct[:nodeNr] == 0
-        nodetab = cstruct.nodeTab
-        cstruct[:nodeNr].times do |j|
-          node_cstruct = LibXML::XmlNode.new(nodetab[j])
-          if node_cstruct[:type] != XML::Node::NAMESPACE_DECL
-            node = Node.wrap(node_cstruct)
-            node.unlink
-            nodetab[j] = node.cstruct.pointer
-          end
-        end
-        cstruct.nodeTab = nodetab
-        self
-      end
-
-      def self.new document, list = [] # :nodoc:
-        set = NodeSet.wrap(LibXML.xmlXPathNodeSetCreate(nil), document)
-        set.document = document
-        list.each { |x| set << x }
-        yield set if block_given?
-        set
-      end
-
-      def self.wrap(ptr, document) # :nodoc:
-        set = allocate
-        set.cstruct = LibXML::XmlNodeSet.new(ptr)
-        if document
-          set.document = document
-          document.decorate(set)
-        end
-        set
-      end
-
-      private
-
-      def index_at(number) # :nodoc:
-        return nil if (number >= cstruct[:nodeNr] || number.abs > cstruct[:nodeNr])
-        number = number + cstruct[:nodeNr] if number < 0
-        node_ptr = cstruct.nodeAt(number)
-        node_cstruct = LibXML::XmlNode.new(node_ptr)
-        if node_cstruct[:type] == XML::Node::NAMESPACE_DECL
-          Namespace.wrap(document.cstruct, node_ptr)
-        else
-          Node.wrap(node_cstruct)
-        end
-      end
-
-      def subseq(beg, len) # :nodoc:
-        return nil if beg > cstruct[:nodeNr]
-        return nil if beg < 0 || len < 0
-        len = cstruct[:nodeNr] - beg if beg + len > cstruct[:nodeNr]
-
-        set = NodeSet.wrap(LibXML.xmlXPathNodeSetCreate(nil), self.document)
-        beg.upto(beg+len-1) do |j|
-          LibXML.xmlXPathNodeSetAddUnique(set.cstruct, cstruct.nodeAt(j));
-        end
-        set
-      end
-
-    end
-  end
-end

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

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

@@ -1,236 +0,0 @@
-# :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::Buffer.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 base_uri
-        val = LibXML.xmlTextReaderConstBaseUri(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 empty_element?
-        LibXML.xmlTextReaderIsEmptyElement(cstruct) != 0
-      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

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