nokogiri 1.3.1 → 1.3.2

data/lib/nokogiri/ffi/io_callbacks.rb

@@ -2,22 +2,30 @@ module Nokogiri
   module IoCallbacks # :nodoc:
     
     class << self
+
+      def plain_old_reader(io)
+        lambda do |ctx, buffer, len|
+          string = io.read(len)
+          return 0 if string.nil?
+          buffer.put_bytes(0, string, 0, string.length)
+          string.length
+        end
+      end
+
       if defined?(FFI::IO.native_read)
-        def reader(io)
-          lambda do |ctx, buffer, len|
-            rcode = FFI::IO.native_read(io, buffer, len)
-            (rcode < 0) ? 0 : rcode
+        def ffi_io_native_reader(io)
+          if io.is_a?(StringIO)
+            plain_old_reader(io)
+          else
+            lambda do |ctx, buffer, len|
+              rcode = FFI::IO.native_read(io, buffer, len)
+              (rcode < 0) ? 0 : rcode
+            end
           end
         end
+        alias :reader :ffi_io_native_reader
       else
-        def reader(io) # TODO: this can be removed once JRuby 1.3.0RC2 and ruby-ffi 0.4.0 are both released
-          lambda do |ctx, buffer, len|
-            string = io.read(len)
-            return 0 if string.nil?
-            buffer.put_bytes(0, string, 0, string.length)
-            string.length
-          end
-        end
+        alias :reader :plain_old_reader
       end
 
       def writer(io)

data/lib/nokogiri/ffi/libxml.rb

@@ -118,6 +118,7 @@ module Nokogiri
     attach_function :xmlStringGetNodeList, [:pointer, :pointer], :pointer # second arg should be a :string, but we only ship the results of xmlEncodeEntitiesReentrant, so let's optimize.
     attach_function :xmlNewNs, [:pointer, :string, :string], :pointer
     attach_function :xmlNewNsProp, [:pointer, :pointer, :string, :string], :pointer
+    attach_function :xmlSearchNs, [:pointer, :pointer, :string], :pointer
     attach_function :xmlSearchNsByHref, [:pointer, :pointer, :string], :pointer
     attach_function :xmlGetIntSubset, [:pointer], :pointer
     attach_function :xmlBufferCreate, [], :pointer
@@ -126,6 +127,11 @@ module Nokogiri
     attach_function :xmlNewDocProp, [:pointer, :string, :string], :pointer
     attach_function :xmlFreePropList, [:pointer], :void
 
+    # valid.c
+    attach_function :xmlNewValidCtxt, [], :pointer
+    attach_function :xmlValidateDtd, [:pointer, :pointer, :pointer], :int
+    attach_function :xmlFreeValidCtxt, [:pointer], :void
+
     # xmlsave.c
     attach_function :xmlDocDumpMemory, [:pointer, :pointer, :pointer], :void
     attach_function :xmlNodeDump, [:pointer, :pointer, :pointer, :int, :int], :int
@@ -240,6 +246,7 @@ module Nokogiri
     attach_function :xmlSchemaSetParserStructuredErrors, [:pointer, :syntax_error_handler, :pointer], :void unless Nokogiri.is_2_6_16?
     attach_function :xmlSchemaParse, [:pointer], :pointer
     attach_function :xmlSchemaFreeParserCtxt, [:pointer], :void
+    attach_function :xmlSchemaNewDocParserCtxt, [:pointer], :pointer
 
     # relaxng.c
     attach_function :xmlRelaxNGNewValidCtxt, [:pointer], :pointer
@@ -250,6 +257,7 @@ module Nokogiri
     attach_function :xmlRelaxNGSetParserStructuredErrors, [:pointer, :syntax_error_handler, :pointer], :void unless Nokogiri.is_2_6_16?
     attach_function :xmlRelaxNGParse, [:pointer], :pointer
     attach_function :xmlRelaxNGFreeParserCtxt, [:pointer], :void
+    attach_function :xmlRelaxNGNewDocParserCtxt, [:pointer], :pointer
 
     # helpers
     def self.pointer_offset(n)

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

@@ -84,7 +84,7 @@ module Nokogiri
           LibXML.xmlSetStructuredErrorFunc(nil, SyntaxError.error_array_pusher(error_list))
 
           ptr = yield
-          
+
           LibXML.xmlSetStructuredErrorFunc(nil, nil)
 
           if ptr.null?

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

@@ -1,16 +1,30 @@
 module Nokogiri
   module XML
     class DTD < Node
-      
-      def elements # :nodoc:
+      # :stopdoc:
+      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 elements
         internal_attributes :elements
       end
 
-      def entities # :nodoc:
+      def entities
         internal_attributes :entities
       end
 
-      def notations # :nodoc:
+      def notations
         attr_ptr = cstruct[:notations]
         return nil if attr_ptr.null?
 
@@ -24,8 +38,9 @@ module Nokogiri
         ahash
       end
 
-    private
-      def internal_attributes(attr_name) # :nodoc:
+      private
+
+      def internal_attributes attr_name
         attr_ptr = cstruct[attr_name.to_sym]
         return nil if attr_ptr.null?
 
@@ -37,6 +52,7 @@ module Nokogiri
         ahash
       end
 
+      # :startdoc:
     end
   end
 end

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

@@ -1,20 +1,21 @@
 module Nokogiri
   module XML
-    class Namespace # :nodoc:
+    class Namespace
+      # :stopdoc:
 
-      attr_accessor :cstruct # :nodoc:
-      attr_accessor :document # :nodoc:
+      attr_accessor :cstruct
+      attr_accessor :document
 
-      def prefix  # :nodoc:
+      def prefix
         cstruct[:prefix].nil? ? nil : cstruct[:prefix] # TODO: encoding?
       end
 
-      def href # :nodoc:
+      def href
         cstruct[:href].nil? ? nil : cstruct[:href] # TODO: encoding?
       end
 
       class << self
-        def wrap(document, node_struct) # :nodoc:
+        def wrap(document, node_struct)
           if node_struct.is_a?(FFI::Pointer)
             # cast native pointers up into a node cstruct
             return nil if node_struct.null?
@@ -27,7 +28,7 @@ module Nokogiri
           ns = Nokogiri::XML::Namespace.allocate
           ns.document = document.ruby_doc
           ns.cstruct = node_struct
-          
+
           ns.cstruct.ruby_node = ns
 
           cache = ns.document.instance_variable_get(:@node_cache)
@@ -37,6 +38,7 @@ module Nokogiri
         end
       end
 
+      # :startdoc:
     end
   end
 end

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

@@ -215,6 +215,10 @@ module Nokogiri
 
       def add_namespace_definition(prefix, href) # :nodoc:
         ns = LibXML.xmlNewNs(cstruct, href, prefix)
+        if ns.null?
+          ns = LibXML.xmlSearchNs(cstruct.document, cstruct,
+            prefix.nil? ? nil : prefix.to_s)
+        end
         LibXML.xmlSetNs(cstruct, ns) if prefix.nil?
         Namespace.wrap(cstruct.document, ns)
       end

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

@@ -23,7 +23,10 @@ module Nokogiri
         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)
+
+        new_set = NodeSet.wrap(new_set_ptr)
+        new_set.document = document
+        new_set
       end
 
       def -(node_set) # :nodoc:

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

@@ -1,7 +1,8 @@
 module Nokogiri
   module XML
     class RelaxNG < Schema
-      def validate_document(document) # :nodoc:
+      # :stopdoc:
+      def validate_document document
         errors = []
 
         ctx = LibXML.xmlRelaxNGNewValidCtxt(cstruct)
@@ -18,8 +19,9 @@ module Nokogiri
       end
       private :validate_document
 
-      def self.read_memory(content) # :nodoc:
-        ctx = LibXML.xmlRelaxNGNewMemParserCtxt(content, content.length)
+      def self.read_memory content
+        content_copy = FFI::MemoryPointer.from_string(content)
+        ctx = LibXML.xmlRelaxNGNewMemParserCtxt(content_copy, content.length)
 
         errors = []
 
@@ -46,6 +48,36 @@ module Nokogiri
         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)
+
+        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
+      # :startdoc:
     end
   end
 end

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

@@ -2,7 +2,7 @@ module Nokogiri
   module XML
     module SAX
       class Parser
-        
+
         attr_accessor :cstruct # :nodoc:
 
         def parse_memory(data) # :nodoc:
@@ -35,7 +35,7 @@ module Nokogiri
 
         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.
@@ -97,17 +97,21 @@ module Nokogiri
           prefix    = prefix   .null? ? nil : prefix   .read_string
           uri       = uri      .null? ? nil : uri      .read_string
 
-          attr_hash = {}
-          ns_hash   = {}
+          attr_list = []
+          ns_list   = []
 
           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
+              attr_prefix = attributes.get_pointer(LibXML.pointer_offset(j + 1))
+              attr_prefix = attr_prefix.null? ? nil : attr_prefix.read_string
+              attr_uri = attributes.get_pointer(LibXML.pointer_offset(j + 2))
+              attr_uri = attr_uri.null? ? nil : attr_uri.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
+              attr_list << Attribute.new(key, attr_prefix, attr_uri, value)
             end
           end
 
@@ -117,16 +121,18 @@ module Nokogiri
               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
+              ns_list << [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
+          @document.start_element_namespace(
+            localname,
+            attr_list,
+            prefix,
+            uri,
+            ns_list
+          )
+          start_element_namespace(localname, attr_list, prefix, uri, ns_list)
         end
 
         def __internal__endElementNs(_, localname, prefix, uri) # :nodoc:
@@ -134,14 +140,9 @@ module Nokogiri
           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
+          @document.end_element_namespace(localname, prefix, uri)
+          end_element_namespace(localname, prefix, uri)
         end
-
       end
     end
   end

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

@@ -1,10 +1,11 @@
 module Nokogiri
   module XML
     class Schema
+      # :stopdoc:
 
-      attr_accessor :cstruct # :nodoc:
+      attr_accessor :cstruct
 
-      def validate_document(document) # :nodoc:
+      def validate_document document
         errors = []
 
         ctx = LibXML.xmlSchemaNewValidCtxt(cstruct)
@@ -21,8 +22,9 @@ module Nokogiri
       end
       private :validate_document
 
-      def self.read_memory(content) # :nodoc:
-        ctx = LibXML.xmlSchemaNewMemParserCtxt(content, content.length)
+      def self.read_memory content
+        content_copy = FFI::MemoryPointer.from_string(content)
+        ctx = LibXML.xmlSchemaNewMemParserCtxt(content_copy, content.length)
 
         errors = []
 
@@ -49,6 +51,41 @@ module Nokogiri
         schema
       end
 
+      def self.from_document document
+        ctx = LibXML.xmlSchemaNewDocParserCtxt(document.document.cstruct)
+
+        errors = []
+
+        LibXML.xmlSetStructuredErrorFunc(nil, SyntaxError.error_array_pusher(errors))
+        unless Nokogiri.is_2_6_16?
+          LibXML.xmlSchemaSetParserStructuredErrors(
+            ctx,
+            SyntaxError.error_array_pusher(errors),
+            nil
+          )
+        end
+
+        schema_ptr = LibXML.xmlSchemaParse(ctx)
+
+        LibXML.xmlSetStructuredErrorFunc(nil, nil)
+        LibXML.xmlSchemaFreeParserCtxt(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::XmlSchema.new schema_ptr
+        schema.errors = errors
+        schema
+      end
+
+      # :startdoc:
     end
   end
 end

data/lib/nokogiri/html.rb

@@ -8,7 +8,7 @@ module Nokogiri
   class << self
     ###
     # Parse HTML.  Convenience method for Nokogiri::HTML::Document.parse
-    def HTML thing, url = nil, encoding = nil, options = 2145, &block
+    def HTML thing, url = nil, encoding = nil, options = XML::ParseOptions::DEFAULT_HTML, &block
       Nokogiri::HTML::Document.parse(thing, url, encoding, options, &block)
     end
   end
@@ -17,7 +17,7 @@ module Nokogiri
     class << self
       ###
       # Parse HTML.  Convenience method for Nokogiri::HTML::Document.parse
-      def parse thing, url = nil, encoding = nil, options = 2145, &block
+      def parse thing, url = nil, encoding = nil, options = XML::ParseOptions::DEFAULT_HTML, &block
         Document.parse(thing, url, encoding, options, &block)
       end
 

data/lib/nokogiri/html/document.rb

@@ -44,9 +44,9 @@ Please change to #{self.class}#serialize(:encoding => enc, :save_with => opts)
         # +url+ is resource where this document is located.  +encoding+ is the
         # encoding that should be used when processing the document. +options+
         # is a number that sets options in the parser, such as
-        # Nokogiri::XML::PARSE_RECOVER.  See the constants in
-        # Nokogiri::XML.
-        def parse string_or_io, url = nil, encoding = nil, options = 2145, &block
+        # Nokogiri::XML::ParseOptions::RECOVER.  See the constants in
+        # Nokogiri::XML::ParseOptions.
+        def parse string_or_io, url = nil, encoding = nil, options = XML::ParseOptions::DEFAULT_HTML, &block
 
           options = Nokogiri::XML::ParseOptions.new(options) if Fixnum === options
           # Give the options to the user