nokogiri 1.4.1 → 1.4.2

data/lib/nokogiri/css/generated_tokenizer.rb

@@ -29,7 +29,6 @@ class GeneratedTokenizer < GeneratedParser
     scan_setup(str)
     do_parse
   end
-  alias :scan :scan_str
 
   def load_file( filename )
     @filename = filename
@@ -52,79 +51,79 @@ class GeneratedTokenizer < GeneratedParser
     token = case @state
     when nil
       case
-      when (text = @ss.scan(/has\([\s\r\n\f]*/))
+      when (text = @ss.scan(/has\([\s]*/))
          action { [:HAS, text] }
 
-      when (text = @ss.scan(/[-@]?([_A-Za-z]|[^\0-\177]|\\[0-9A-Fa-f]{1,6}(\r\n|[\s\n\r\t\f])?|\\[^\n\r\f0-9A-Fa-f])([_A-Za-z0-9-]|[^\0-\177]|\\[0-9A-Fa-f]{1,6}(\r\n|[\s\n\r\t\f])?|\\[^\n\r\f0-9A-Fa-f])*\([\s\r\n\f]*/))
+      when (text = @ss.scan(/[-@]?([_A-Za-z]|[^\0-\177]|\\[0-9A-Fa-f]{1,6}(\r\n|[\s])?|\\[^\n\r\f0-9A-Fa-f])([_A-Za-z0-9-]|[^\0-\177]|\\[0-9A-Fa-f]{1,6}(\r\n|[\s])?|\\[^\n\r\f0-9A-Fa-f])*\([\s]*/))
          action { [:FUNCTION, text] }
 
-      when (text = @ss.scan(/[-@]?([_A-Za-z]|[^\0-\177]|\\[0-9A-Fa-f]{1,6}(\r\n|[\s\n\r\t\f])?|\\[^\n\r\f0-9A-Fa-f])([_A-Za-z0-9-]|[^\0-\177]|\\[0-9A-Fa-f]{1,6}(\r\n|[\s\n\r\t\f])?|\\[^\n\r\f0-9A-Fa-f])*/))
+      when (text = @ss.scan(/[-@]?([_A-Za-z]|[^\0-\177]|\\[0-9A-Fa-f]{1,6}(\r\n|[\s])?|\\[^\n\r\f0-9A-Fa-f])([_A-Za-z0-9-]|[^\0-\177]|\\[0-9A-Fa-f]{1,6}(\r\n|[\s])?|\\[^\n\r\f0-9A-Fa-f])*/))
          action { [:IDENT, text] }
 
-      when (text = @ss.scan(/\#([_A-Za-z0-9-]|[^\0-\177]|\\[0-9A-Fa-f]{1,6}(\r\n|[\s\n\r\t\f])?|\\[^\n\r\f0-9A-Fa-f])+/))
+      when (text = @ss.scan(/\#([_A-Za-z0-9-]|[^\0-\177]|\\[0-9A-Fa-f]{1,6}(\r\n|[\s])?|\\[^\n\r\f0-9A-Fa-f])+/))
          action { [:HASH, text] }
 
-      when (text = @ss.scan(/[\s\r\n\f]*~=[\s\r\n\f]*/))
+      when (text = @ss.scan(/[\s]*~=[\s]*/))
          action { [:INCLUDES, text] }
 
-      when (text = @ss.scan(/[\s\r\n\f]*\|=[\s\r\n\f]*/))
+      when (text = @ss.scan(/[\s]*\|=[\s]*/))
          action { [:DASHMATCH, text] }
 
-      when (text = @ss.scan(/[\s\r\n\f]*\^=[\s\r\n\f]*/))
+      when (text = @ss.scan(/[\s]*\^=[\s]*/))
          action { [:PREFIXMATCH, text] }
 
-      when (text = @ss.scan(/[\s\r\n\f]*\$=[\s\r\n\f]*/))
+      when (text = @ss.scan(/[\s]*\$=[\s]*/))
          action { [:SUFFIXMATCH, text] }
 
-      when (text = @ss.scan(/[\s\r\n\f]*\*=[\s\r\n\f]*/))
+      when (text = @ss.scan(/[\s]*\*=[\s]*/))
          action { [:SUBSTRINGMATCH, text] }
 
-      when (text = @ss.scan(/[\s\r\n\f]*!=[\s\r\n\f]*/))
+      when (text = @ss.scan(/[\s]*!=[\s]*/))
          action { [:NOT_EQUAL, text] }
 
-      when (text = @ss.scan(/[\s\r\n\f]*=[\s\r\n\f]*/))
+      when (text = @ss.scan(/[\s]*=[\s]*/))
          action { [:EQUAL, text] }
 
-      when (text = @ss.scan(/[\s\r\n\f]*\)/))
+      when (text = @ss.scan(/[\s]*\)/))
          action { [:RPAREN, text] }
 
-      when (text = @ss.scan(/[\s\r\n\f]*\[[\s\r\n\f]*/))
+      when (text = @ss.scan(/[\s]*\[[\s]*/))
          action { [:LSQUARE, text] }
 
-      when (text = @ss.scan(/[\s\r\n\f]*\]/))
+      when (text = @ss.scan(/[\s]*\]/))
          action { [:RSQUARE, text] }
 
-      when (text = @ss.scan(/[\s\r\n\f]*\+[\s\r\n\f]*/))
+      when (text = @ss.scan(/[\s]*\+[\s]*/))
          action { [:PLUS, text] }
 
-      when (text = @ss.scan(/[\s\r\n\f]*>[\s\r\n\f]*/))
+      when (text = @ss.scan(/[\s]*>[\s]*/))
          action { [:GREATER, text] }
 
-      when (text = @ss.scan(/[\s\r\n\f]*,[\s\r\n\f]*/))
+      when (text = @ss.scan(/[\s]*,[\s]*/))
          action { [:COMMA, text] }
 
-      when (text = @ss.scan(/[\s\r\n\f]*~[\s\r\n\f]*/))
+      when (text = @ss.scan(/[\s]*~[\s]*/))
          action { [:TILDE, text] }
 
-      when (text = @ss.scan(/\:not\([\s\r\n\f]*/))
+      when (text = @ss.scan(/\:not\([\s]*/))
          action { [:NOT, text] }
 
       when (text = @ss.scan(/-?([0-9]+|[0-9]*\.[0-9]+)/))
          action { [:NUMBER, text] }
 
-      when (text = @ss.scan(/[\s\r\n\f]*\/\/[\s\r\n\f]*/))
+      when (text = @ss.scan(/[\s]*\/\/[\s]*/))
          action { [:DOUBLESLASH, text] }
 
-      when (text = @ss.scan(/[\s\r\n\f]*\/[\s\r\n\f]*/))
+      when (text = @ss.scan(/[\s]*\/[\s]*/))
          action { [:SLASH, text] }
 
       when (text = @ss.scan(/U\+[0-9a-f?]{1,6}(-[0-9a-f]{1,6})?/))
          action {[:UNICODE_RANGE, text] }
 
-      when (text = @ss.scan(/[\s\t\r\n\f]+/))
+      when (text = @ss.scan(/[\s]+/))
          action { [:S, text] }
 
-      when (text = @ss.scan(/"([^\n\r\f"]|\n|\r\n|\r|\f|[^\0-\177]|\\[0-9A-Fa-f]{1,6}(\r\n|[\s\n\r\t\f])?|\\[^\n\r\f0-9A-Fa-f])*"|'([^\n\r\f']|\n|\r\n|\r|\f|[^\0-\177]|\\[0-9A-Fa-f]{1,6}(\r\n|[\s\n\r\t\f])?|\\[^\n\r\f0-9A-Fa-f])*'/))
+      when (text = @ss.scan(/"([^\n\r\f"]|\n|\r\n|\r|\f|[^\0-\177]|\\[0-9A-Fa-f]{1,6}(\r\n|[\s])?|\\[^\n\r\f0-9A-Fa-f])*"|'([^\n\r\f']|\n|\r\n|\r|\f|[^\0-\177]|\\[0-9A-Fa-f]{1,6}(\r\n|[\s])?|\\[^\n\r\f0-9A-Fa-f])*'/))
          action { [:STRING, text] }
 
       when (text = @ss.scan(/./))

data/lib/nokogiri/css/parser.y

@@ -222,7 +222,9 @@ rule
       }
     ;
   negation_arg
-    : hcap_1toN
+    : element_name
+    | element_name hcap_1toN
+    | hcap_1toN
     ;
 end
 

data/lib/nokogiri/css/tokenizer.rex

@@ -4,10 +4,10 @@ class GeneratedTokenizer < GeneratedParser
 
 macro
   nl        \n|\r\n|\r|\f
-  w         [\s\r\n\f]*
+  w         [\s]*
   nonascii  [^\0-\177]
   num       -?([0-9]+|[0-9]*\.[0-9]+)
-  unicode   \\[0-9A-Fa-f]{1,6}(\r\n|[\s\n\r\t\f])?
+  unicode   \\[0-9A-Fa-f]{1,6}(\r\n|[\s])?
 
   escape    {unicode}|\\[^\n\r\f0-9A-Fa-f]
   nmchar    [_A-Za-z0-9-]|{nonascii}|{escape}
@@ -47,7 +47,7 @@ rule
             
             U\+[0-9a-f?]{1,6}(-[0-9a-f]{1,6})?  {[:UNICODE_RANGE, text] }
             
-            [\s\t\r\n\f]+    { [:S, text] }
+            [\s]+            { [:S, text] }
             {string}         { [:STRING, text] }
             .                { [text, text] }
 end

data/lib/nokogiri/css/xpath_visitor.rb

@@ -40,7 +40,12 @@ module Nokogiri
       end
 
       def visit_not node
-        'not(' + node.value.first.accept(self) + ')'
+        child = node.value.first
+        if :ELEMENT_NAME == child.type
+          "not(self::#{child.accept(self)})"
+        else
+          "not(#{child.accept(self)})"
+        end
       end
 
       def visit_preceding_selector node
@@ -100,8 +105,8 @@ module Nokogiri
           return self.send(msg, node) if self.respond_to?(msg)
 
           case node.value.first
-          when "first" then "position() = 1"
-          when "last" then "position() = last()"
+          when "first", "first-child" then "position() = 1"
+          when "last", "last-child" then "position() = last()"
           when "first-of-type" then "position() = 1"
           when "last-of-type" then "position() = last()"
           when "only-of-type" then "last() = 1"

data/lib/nokogiri/ffi/html/sax/parser_context.rb

@@ -20,9 +20,9 @@ module Nokogiri
           pc = allocate
           pc.cstruct = LibXML::XmlParserContext.new ctx
           if encoding
-            enc = LibXML.xmlParseCharEncoding(encoding)
-            if enc != LibXML::XML_CHAR_ENCODING_ERROR
-              LibXML.xmlSwitchEncoding(ctx, enc)
+            enc = LibXML.xmlFindCharEncodingHandler(encoding)
+            if !enc.null?
+              LibXML.xmlSwitchToEncoding(ctx, enc)
             end
           end
           pc

data/lib/nokogiri/ffi/libxml.rb

@@ -2,7 +2,7 @@
 module Nokogiri
   module LibXML
     extend FFI::Library
-    if RUBY_PLATFORM =~ /java/ && java.lang.System.getProperty('os.name') =~ /windows/i
+    if RUBY_PLATFORM =~ /java/ && RbConfig::CONFIG['host_os'] =~ /(mswin|mingw)/i
       raise(RuntimeError, "Nokogiri requires JRuby 1.4.0 or later on Windows") if JRUBY_VERSION < "1.4.0"
       dll_dir = File.expand_path(File.join(File.dirname(__FILE__), "..", "..", "..", "ext", "nokogiri"))
       libs = ["libxml2.dll", "libxslt.dll", "libexslt.dll"].collect do |lib|
@@ -80,6 +80,7 @@ module Nokogiri
     attach_function :htmlCreateMemoryParserCtxt, [:pointer, :int], :pointer
     attach_function :htmlCreateFileParserCtxt, [:pointer, :pointer], :pointer
     attach_function :htmlParseDocument, [:pointer], :int
+    attach_function :htmlHandleOmittedElem, [:int], :int
 
     # HTMLtree.c
     attach_function :htmlDocDumpMemory, [:pointer, :pointer, :pointer], :void
@@ -101,6 +102,7 @@ module Nokogiri
     attach_function :xmlCreatePushParserCtxt, [:pointer, :pointer, :string, :int, :string], :pointer
     attach_function :xmlParseChunk, [:pointer, :string, :int, :int], :int
     attach_function :xmlCtxtUseOptions, [:pointer, :int], :int
+    attach_function :xmlParseInNodeContext, [:pointer, :string, :int, :int, :pointer], :pointer
 
     # tree.c
     attach_function :xmlNewDoc, [:string], :pointer
@@ -111,6 +113,10 @@ module Nokogiri
     attach_function :xmlFreeDoc, [:pointer], :void
     attach_function :xmlSetTreeDoc, [:pointer, :pointer], :void
     attach_function :xmlNewReference, [:pointer, :string], :pointer
+    attach_function :xmlFirstElementChild, [:pointer], :pointer
+    attach_function :xmlLastElementChild, [:pointer], :pointer
+    attach_function :xmlNextElementSibling, [:pointer], :pointer
+    attach_function :xmlPreviousElementSibling, [:pointer], :pointer
     attach_function :xmlNewNode, [:pointer, :string], :pointer
     attach_function :xmlCopyNode, [:pointer, :int], :pointer
     attach_function :xmlDocCopyNode, [:pointer, :pointer, :int], :pointer
@@ -149,6 +155,8 @@ module Nokogiri
     attach_function :xmlFreePropList, [:pointer], :void
     attach_function :xmlCreateIntSubset, [:pointer] * 4, :pointer
     attach_function :xmlNewDtd, [:pointer] * 4, :pointer
+    attach_function :xmlGetNsList, [:pointer, :pointer], :pointer
+    attach_function :xmlTextMerge, [:pointer, :pointer], :pointer
 
     # valid.c
     attach_function :xmlNewValidCtxt, [], :pointer
@@ -165,6 +173,7 @@ module Nokogiri
 
     # entities.c
     attach_function :xmlEncodeSpecialChars, [:pointer, :string], :pointer # returns char* that must be freed
+    attach_function :xmlAddDocEntity, [:pointer, :string, :int, :string, :string, :string], :pointer
 
     # xpath.c
     attach_function :xmlXPathInit, [], :void
@@ -175,6 +184,7 @@ module Nokogiri
     attach_function :xmlXPathCmpNodes, [:pointer, :pointer], :int
     attach_function :xmlXPathNodeSetContains, [:pointer, :pointer], :int
     attach_function :xmlXPathNodeSetAdd, [:pointer, :pointer], :void
+    attach_function :xmlXPathNodeSetAddUnique, [:pointer, :pointer], :void
     attach_function :xmlXPathNodeSetRemove, [:pointer, :int], :void
     attach_function :xmlXPathNodeSetCreate, [:pointer], :pointer
     attach_function :xmlXPathNodeSetDel, [:pointer, :pointer], :void
@@ -248,6 +258,7 @@ module Nokogiri
     attach_function :xmlTextReaderConstPrefix, [:pointer], :pointer # returns a const char* that is deallocated with the reader
     attach_function :xmlTextReaderConstValue, [:pointer], :pointer # returns a const char* that is deallocated on the next read()
     attach_function :xmlTextReaderConstXmlVersion, [:pointer], :pointer # returns a const char* that is deallocated with the reader
+    attach_function :xmlTextReaderConstBaseUri, [:pointer], :pointer # returns a const char* that is deallocated with the reader
     attach_function :xmlTextReaderReadState, [:pointer], :int
     attach_function :xmlTextReaderHasValue, [:pointer], :int
     attach_function :xmlFreeTextReader, [:pointer], :void
@@ -274,6 +285,7 @@ module Nokogiri
     attach_function :xmlSchemaParse, [:pointer], :pointer
     attach_function :xmlSchemaFreeParserCtxt, [:pointer], :void
     attach_function :xmlSchemaNewDocParserCtxt, [:pointer], :pointer
+    attach_function :xmlSchemaValidateFile, [:pointer, :string, :int], :int
 
     # relaxng.c
     attach_function :xmlRelaxNGNewValidCtxt, [:pointer], :pointer
@@ -285,13 +297,14 @@ module Nokogiri
     attach_function :xmlRelaxNGParse, [:pointer], :pointer
     attach_function :xmlRelaxNGFreeParserCtxt, [:pointer], :void
     attach_function :xmlRelaxNGNewDocParserCtxt, [:pointer], :pointer
+    attach_function :xmlRelaxNGFree, [:pointer], :void
 
     # libc
     attach_function :calloc, [:int, :int], :pointer
     attach_function :free, [:pointer], :void
 
     attach_function :xmlParseCharEncoding, [:string], :int
-    attach_function :xmlSwitchEncoding, [:pointer, :int], :void
+    attach_function :xmlSwitchToEncoding, [:pointer, :pointer], :void
 
     # helpers
     POINTER_SIZE = FFI.type_size(:pointer)
@@ -308,6 +321,7 @@ require 'nokogiri/xml/syntax_error'
 
 [ "io_callbacks",
   "encoding_handler",
+  "weak_bucket",
   "structs/common_node",
   "structs/xml_alloc",
   "structs/xml_char_encoding_handler",

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

@@ -1,18 +1,25 @@
 module Nokogiri
   module LibXML # :nodoc:
     module CommonNode # :nodoc:
-
       def document
         p = self[:doc]
         p.null? ? nil : LibXML::XmlDocumentCast.new(p)
       end
 
+      def ruby_node_pointer
+        self[:_private]
+      end
+
+      def ruby_node_pointer=(value)
+        self[:_private] = value
+      end
+
       def ruby_node
-        self[:_private] != 0 ? ObjectSpace._id2ref(self[:_private]) : nil
+        Nokogiri::WeakBucket.get_object(self)
       end
 
       def ruby_node= object
-        self[:_private] = object.object_id
+        Nokogiri::WeakBucket.set_object(self, object)
       end
 
       def keep_reference_from_document! # equivalent to NOKOGIRI_ROOT_NODE
@@ -20,6 +27,11 @@ module Nokogiri
         raise "no document to add reference to" unless doc
         LibXML.xmlXPathNodeSetAdd(doc.unlinked_nodes, self)
       end
+
+      def keep_reference_from!(document) # equivalent to NOKOGIRI_ROOT_NSDEF
+        raise "no document to add reference to" unless document
+        LibXML.xmlXPathNodeSetAdd(document.unlinked_nodes, self)
+      end
     end
   end
 end

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

@@ -36,14 +36,21 @@ module Nokogiri
         p.null? ? nil : LibXML::XmlDocumentCast.new(p)
       end
 
+      def ruby_node_pointer
+        tuple = self[:_private]
+        tuple.null? ? 0 : tuple.get_long(0)
+      end
+
+      def ruby_node_pointer=(value)
+        self[:_private].put_long(0, value)
+      end
+
       def ruby_doc
-        ptr = self[:_private]
-        return nil if ptr.null?
-        ObjectSpace._id2ref(ptr.get_long(0))
+        Nokogiri::WeakBucket.get_object(self)
       end
 
       def ruby_doc=(object)
-        self[:_private].put_long(0, object.object_id)
+        Nokogiri::WeakBucket.set_object(self, object)
       end
 
       def unlinked_nodes
@@ -78,6 +85,8 @@ module Nokogiri
             case node_cstruct[:type]
             when Nokogiri::XML::Node::ATTRIBUTE_NODE
               LibXML.xmlFreePropList(node_cstruct)
+            when Nokogiri::XML::Node::NAMESPACE_DECL
+              LibXML.xmlFree(node_cstruct)
             else
               LibXML.xmlAddChild(doc, node_cstruct) if node_cstruct[:parent].null?
             end

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

@@ -16,8 +16,9 @@ module Nokogiri
         LibXML::XmlNode.new(self[:node])
       end
 
-      def doc
-        LibXML::XmlDocumentCast.new(self[:doc])
+      def document
+        p = self[:doc]
+        p.null? ? nil : LibXML::XmlDocumentCast.new(p)
       end
     end
 

data/lib/nokogiri/ffi/weak_bucket.rb

@@ -0,0 +1,40 @@
+# :stopdoc:
+if ENV['NOKOGIRI_ID2REF'] || RUBY_PLATFORM !~ /java/
+  Nokogiri::VERSION_INFO['refs'] = "id2ref"
+else
+  require 'weakling'
+  Nokogiri::VERSION_INFO['refs'] = "weakling"
+end
+require 'singleton'
+
+module Nokogiri
+  class WeakBucket
+    include Singleton
+
+    if Nokogiri::VERSION_INFO['refs'] == "weakling"
+      attr_accessor :bucket
+
+      def initialize
+        @bucket = Weakling::IdHash.new
+      end
+
+      def WeakBucket.get_object(cstruct)
+        instance.bucket[cstruct.ruby_node_pointer]
+      end
+
+      def WeakBucket.set_object(cstruct, object)
+        cstruct.ruby_node_pointer = instance.bucket.add(object)
+      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/document.rb

@@ -11,6 +11,17 @@ module Nokogiri
 
       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)
@@ -70,6 +81,22 @@ module Nokogiri
         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"