nokogiri 1.3.2-x86-mingw32 → 1.3.3-x86-mingw32

data/ext/nokogiri/xml_dtd.c

@@ -113,6 +113,8 @@ static VALUE validate(VALUE self, VALUE document)
   return error_list;
 }
 
+VALUE cNokogiriXmlDtd;
+
 void init_xml_dtd()
 {
   VALUE nokogiri = rb_define_module("Nokogiri");
@@ -124,6 +126,8 @@ void init_xml_dtd()
    */
   VALUE klass = rb_define_class_under(xml, "DTD", node);
 
+  cNokogiriXmlDtd = klass;
+
   rb_define_method(klass, "notations", notations, 0);
   rb_define_method(klass, "elements", elements, 0);
   rb_define_method(klass, "entities", entities, 0);

data/ext/nokogiri/xml_dtd.h

@@ -3,6 +3,8 @@
 
 #include <nokogiri.h>
 
+extern VALUE cNokogiriXmlDtd;
+
 void init_xml_dtd();
 
 #endif

data/ext/nokogiri/xml_node.c

@@ -12,7 +12,10 @@ static void debug_node_dealloc(xmlNodePtr x)
 
 static void mark(xmlNodePtr node)
 {
-  rb_gc_mark(DOC_RUBY_OBJECT(node->doc));
+  // it's OK if the document isn't fully realized (as in XML::Reader).
+  // see http://github.com/tenderlove/nokogiri/issues/closed/#issue/95
+  if (DOC_RUBY_OBJECT_TEST(node->doc) && DOC_RUBY_OBJECT(node->doc))
+    rb_gc_mark(DOC_RUBY_OBJECT(node->doc));
 }
 
 /* :nodoc: */
@@ -60,6 +63,17 @@ static VALUE reparent_node_with(VALUE node_obj, VALUE other_obj, node_other_func
   Data_Get_Struct(node_obj, xmlNode, node);
   Data_Get_Struct(other_obj, xmlNode, other);
 
+  // If a document fragment is added, we need to reparent all of it's children
+  if(node->type == XML_DOCUMENT_FRAG_NODE)
+  {
+    xmlNodePtr child = node->children;
+    while(NULL != child) {
+      reparent_node_with(Nokogiri_wrap_xml_node((VALUE)NULL, child), other_obj, func);
+      child = child->next;
+    }
+    return node_obj;
+  }
+
   if (node->doc == other->doc) {
     xmlUnlinkNode(node) ;
     if ( node->type == XML_TEXT_NODE
@@ -673,6 +687,8 @@ static VALUE native_write_to(
 
   xmlIndentTreeOutput = 1;
 
+  const char * before_indent = xmlTreeIndentString;
+
   xmlTreeIndentString = StringValuePtr(indent_string);
 
   xmlSaveCtxtPtr savectx = xmlSaveToIO(
@@ -685,6 +701,8 @@ static VALUE native_write_to(
 
   xmlSaveTree(savectx, node);
   xmlSaveClose(savectx);
+
+  xmlTreeIndentString = before_indent;
   return io;
 }
 
@@ -754,7 +772,10 @@ static VALUE new(int argc, VALUE *argv, VALUE klass)
   node->doc = doc->doc;
   NOKOGIRI_ROOT_NODE(node);
 
-  VALUE rb_node = Nokogiri_wrap_xml_node(klass, node);
+  VALUE rb_node = Nokogiri_wrap_xml_node(
+      klass == cNokogiriXmlNode ? (VALUE)NULL : klass,
+      node
+  );
   rb_funcall2(rb_node, rb_intern("initialize"), argc, argv);
 
   if(rb_block_given_p()) rb_yield(rb_node);
@@ -774,9 +795,6 @@ static VALUE dump_html(VALUE self)
   xmlNodePtr node ;
   Data_Get_Struct(self, xmlNode, node);
 
-  if(node->doc->type == XML_DOCUMENT_NODE)
-    return rb_funcall(self, rb_intern("to_xml"), 0);
-
   buf = xmlBufferCreate() ;
   htmlNodeDump(buf, node->doc, node);
   VALUE html = NOKOGIRI_STR_NEW2(buf->content, node->doc->encoding);
@@ -845,7 +863,7 @@ VALUE Nokogiri_wrap_xml_node(VALUE klass, xmlNodePtr node)
       klass = cNokogiriXmlCData;
       break;
     case XML_DTD_NODE:
-      klass = rb_const_get(mNokogiriXml, rb_intern("DTD"));
+      klass = cNokogiriXmlDtd;
       break;
     default:
       klass = cNokogiriXmlNode;
@@ -856,13 +874,14 @@ VALUE Nokogiri_wrap_xml_node(VALUE klass, xmlNodePtr node)
   node->_private = (void *)rb_node;
 
   if (DOC_RUBY_OBJECT_TEST(node->doc) && DOC_RUBY_OBJECT(node->doc)) {
+    // it's OK if the document isn't fully realized (as in XML::Reader).
+    // see http://github.com/tenderlove/nokogiri/issues/closed/#issue/95
     document = DOC_RUBY_OBJECT(node->doc);
     node_cache = DOC_NODE_CACHE(node->doc);
+    rb_ary_push(node_cache, rb_node);
+    rb_funcall(document, rb_intern("decorate"), 1, rb_node);
   }
 
-  rb_ary_push(node_cache, rb_node);
-  rb_funcall(document, rb_intern("decorate"), 1, rb_node);
-
   return rb_node ;
 }
 

data/ext/nokogiri/xml_reader.c

@@ -163,13 +163,6 @@ static VALUE attribute_nodes(VALUE self)
   xmlNodePtr ptr = xmlTextReaderExpand(reader);
   if(ptr == NULL) return Qnil;
 
-  // 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.
-  if(! DOC_RUBY_OBJECT_TEST(ptr->doc)) {
-    VALUE rb_doc = Nokogiri_wrap_xml_document(cNokogiriXmlDocument, ptr->doc);
-    RDATA(rb_doc)->dfree = NULL;
-  }
   VALUE enc = rb_iv_get(self, "@encoding");
 
   if(enc != Qnil && NULL == ptr->doc->encoding) {

data/ext/nokogiri/xml_relax_ng.c

@@ -120,7 +120,9 @@ static VALUE from_document(VALUE klass, VALUE document)
   xmlRelaxNGPtr schema = xmlRelaxNGParse(ctx);
 
   xmlSetStructuredErrorFunc(NULL, NULL);
-  xmlRelaxNGFreeParserCtxt(ctx);
+  if (! is_2_6_16()) {
+    xmlRelaxNGFreeParserCtxt(ctx);
+  }
 
   if(NULL == schema) {
     xmlErrorPtr error = xmlGetLastError();
@@ -132,6 +134,10 @@ static VALUE from_document(VALUE klass, VALUE document)
     return Qnil;
   }
 
+  if (is_2_6_16()) {
+    xmlRelaxNGFreeParserCtxt(ctx);
+  }
+
   VALUE rb_schema = Data_Wrap_Struct(klass, 0, dealloc, schema);
   rb_iv_set(rb_schema, "@errors", errors);
 

data/ext/nokogiri/xml_sax_parser.c

@@ -310,6 +310,8 @@ static VALUE allocate(VALUE klass)
 {
   xmlSAXHandlerPtr handler = calloc(1, sizeof(xmlSAXHandler));
 
+  xmlSetStructuredErrorFunc(NULL, NULL);
+
   handler->startDocument = start_document;
   handler->endDocument = end_document;
   handler->startElement = start_element;

data/lib/action-nokogiri.rb

@@ -18,6 +18,7 @@ module ActionController
     # Get your response as a Nokogiri::XML::Document using the
     # Nokogiri.HTML parser
     def html(flavor=nil)
+      warn "@response.html is deprecated and will be removed in nokogiri 1.4.0"
       if flavor == :hpricot
         @_nokogiri_html_hpricot ||= Nokogiri::Hpricot(body)
       else
@@ -29,6 +30,7 @@ module ActionController
     # Get your response as a Nokogiri::XML::Document using the
     # Nokogiri.XML parser
     def xml
+      warn "@response.html is deprecated and will be removed in nokogiri 1.4.0"
       @_nokogiri_xml ||= Nokogiri::XML(body)
     end
 

data/lib/nokogiri.rb

@@ -54,10 +54,16 @@ module Nokogiri
     # Parse an HTML or XML document.  +string+ contains the document.
     def parse string, url = nil, encoding = nil, options = nil
       doc =
-        if string =~ /^\s*<[^Hh>]*html/i # Probably html
-          Nokogiri::HTML::Document.parse(string, url, encoding, options || XML::ParseOptions::DEFAULT_HTML)
+        if string.respond_to?(:read) ||
+          string =~ /^\s*<[^Hh>]*html/i # Probably html
+          Nokogiri::HTML(
+            string,
+            url,
+            encoding, options || XML::ParseOptions::DEFAULT_HTML
+          )
         else
-          Nokogiri::XML::Document.parse(string, url, encoding, options || XML::ParseOptions::DEFAULT_XML)
+          Nokogiri::XML(string, url, encoding,
+                        options || XML::ParseOptions::DEFAULT_XML)
         end
       yield doc if block_given?
       doc

data/lib/nokogiri/css/generated_tokenizer.rb

@@ -1,6 +1,6 @@
 #--
 # DO NOT MODIFY!!!!
-# This file is automatically generated by rex 1.0.3
+# This file is automatically generated by rex 1.0.4
 # from lexical definition file "lib/nokogiri/css/tokenizer.rex".
 #++
 
@@ -11,133 +11,131 @@ class GeneratedTokenizer < GeneratedParser
 
   class ScanError < StandardError ; end
 
-  attr_reader :lineno
-  attr_reader :filename
+  attr_reader   :lineno
+  attr_reader   :filename
+  attr_accessor :state
 
-  def scan_setup ; end
+  def scan_setup(str)
+    @ss = StringScanner.new(str)
+    @lineno =  1
+    @state  = nil
+  end
 
-  def action &block
+  def action(&block)
     yield
   end
 
-  def scan_str( str )
-    scan_evaluate  str
+  def scan_str(str)
+    scan_setup(str)
     do_parse
   end
 
   def load_file( filename )
     @filename = filename
     open(filename, "r") do |f|
-      scan_evaluate  f.read
+      scan_setup(f.read)
     end
   end
 
   def scan_file( filename )
-    load_file  filename
+    load_file(filename)
     do_parse
   end
 
-  def next_token
-    @rex_tokens.shift
-  end
 
-  def scan_evaluate( str )
-    scan_setup
-    @rex_tokens = []
-    @lineno  =  1
-    ss = StringScanner.new(str)
-    state = nil
-    until ss.eos?
-      text = ss.peek(1)
-      @lineno  +=  1  if text == "\n"
-      case state
-      when nil
-        case
-        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*/))
-           @rex_tokens.push action { [:FUNCTION, text] }
+  def next_token
+    return if @ss.eos?
 
-        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])*/))
-           @rex_tokens.push action { [:IDENT, text] }
+    text = @ss.peek(1)
+    @lineno  +=  1  if text == "\n"
+    token = case @state
+    when nil
+      case
+      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*/))
+         action { [:FUNCTION, 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])+/))
-           @rex_tokens.push action { [:HASH, 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])*/))
+         action { [:IDENT, text] }
 
-        when (text = ss.scan(/[\s\r\n\f]*~=[\s\r\n\f]*/))
-           @rex_tokens.push action { [:INCLUDES, 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])+/))
+         action { [:HASH, text] }
 
-        when (text = ss.scan(/[\s\r\n\f]*\|=[\s\r\n\f]*/))
-           @rex_tokens.push action { [:DASHMATCH, text] }
+      when (text = @ss.scan(/[\s\r\n\f]*~=[\s\r\n\f]*/))
+         action { [:INCLUDES, text] }
 
-        when (text = ss.scan(/[\s\r\n\f]*\^=[\s\r\n\f]*/))
-           @rex_tokens.push action { [:PREFIXMATCH, text] }
+      when (text = @ss.scan(/[\s\r\n\f]*\|=[\s\r\n\f]*/))
+         action { [:DASHMATCH, text] }
 
-        when (text = ss.scan(/[\s\r\n\f]*\$=[\s\r\n\f]*/))
-           @rex_tokens.push action { [:SUFFIXMATCH, text] }
+      when (text = @ss.scan(/[\s\r\n\f]*\^=[\s\r\n\f]*/))
+         action { [:PREFIXMATCH, text] }
 
-        when (text = ss.scan(/[\s\r\n\f]*\*=[\s\r\n\f]*/))
-           @rex_tokens.push action { [:SUBSTRINGMATCH, text] }
+      when (text = @ss.scan(/[\s\r\n\f]*\$=[\s\r\n\f]*/))
+         action { [:SUFFIXMATCH, text] }
 
-        when (text = ss.scan(/[\s\r\n\f]*!=[\s\r\n\f]*/))
-           @rex_tokens.push action { [:NOT_EQUAL, text] }
+      when (text = @ss.scan(/[\s\r\n\f]*\*=[\s\r\n\f]*/))
+         action { [:SUBSTRINGMATCH, text] }
 
-        when (text = ss.scan(/[\s\r\n\f]*=[\s\r\n\f]*/))
-           @rex_tokens.push action { [:EQUAL, text] }
+      when (text = @ss.scan(/[\s\r\n\f]*!=[\s\r\n\f]*/))
+         action { [:NOT_EQUAL, text] }
 
-        when (text = ss.scan(/[\s\r\n\f]*\)/))
-           @rex_tokens.push action { [:RPAREN, text] }
+      when (text = @ss.scan(/[\s\r\n\f]*=[\s\r\n\f]*/))
+         action { [:EQUAL, text] }
 
-        when (text = ss.scan(/[\s\r\n\f]*\[[\s\r\n\f]*/))
-           @rex_tokens.push action { [:LSQUARE, text] }
+      when (text = @ss.scan(/[\s\r\n\f]*\)/))
+         action { [:RPAREN, text] }
 
-        when (text = ss.scan(/[\s\r\n\f]*\]/))
-           @rex_tokens.push action { [:RSQUARE, text] }
+      when (text = @ss.scan(/[\s\r\n\f]*\[[\s\r\n\f]*/))
+         action { [:LSQUARE, text] }
 
-        when (text = ss.scan(/[\s\r\n\f]*\+[\s\r\n\f]*/))
-           @rex_tokens.push action { [:PLUS, text] }
+      when (text = @ss.scan(/[\s\r\n\f]*\]/))
+         action { [:RSQUARE, text] }
 
-        when (text = ss.scan(/[\s\r\n\f]*>[\s\r\n\f]*/))
-           @rex_tokens.push action { [:GREATER, text] }
+      when (text = @ss.scan(/[\s\r\n\f]*\+[\s\r\n\f]*/))
+         action { [:PLUS, text] }
 
-        when (text = ss.scan(/[\s\r\n\f]*,[\s\r\n\f]*/))
-           @rex_tokens.push action { [:COMMA, text] }
+      when (text = @ss.scan(/[\s\r\n\f]*>[\s\r\n\f]*/))
+         action { [:GREATER, text] }
 
-        when (text = ss.scan(/[\s\r\n\f]*~[\s\r\n\f]*/))
-           @rex_tokens.push action { [:TILDE, text] }
+      when (text = @ss.scan(/[\s\r\n\f]*,[\s\r\n\f]*/))
+         action { [:COMMA, text] }
 
-        when (text = ss.scan(/\:not\([\s\r\n\f]*/))
-           @rex_tokens.push action { [:NOT, text] }
+      when (text = @ss.scan(/[\s\r\n\f]*~[\s\r\n\f]*/))
+         action { [:TILDE, text] }
 
-        when (text = ss.scan(/-?([0-9]+|[0-9]*\.[0-9]+)/))
-           @rex_tokens.push action { [:NUMBER, text] }
+      when (text = @ss.scan(/\:not\([\s\r\n\f]*/))
+         action { [:NOT, text] }
 
-        when (text = ss.scan(/[\s\r\n\f]*\/\/[\s\r\n\f]*/))
-           @rex_tokens.push action { [:DOUBLESLASH, 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]*/))
-           @rex_tokens.push action { [:SLASH, text] }
+      when (text = @ss.scan(/[\s\r\n\f]*\/\/[\s\r\n\f]*/))
+         action { [:DOUBLESLASH, text] }
 
-        when (text = ss.scan(/U\+[0-9a-f?]{1,6}(-[0-9a-f]{1,6})?/))
-           @rex_tokens.push action {[:UNICODE_RANGE, text] }
+      when (text = @ss.scan(/[\s\r\n\f]*\/[\s\r\n\f]*/))
+         action { [:SLASH, text] }
 
-        when (text = ss.scan(/[\s\t\r\n\f]+/))
-           @rex_tokens.push action { [:S, text] }
+      when (text = @ss.scan(/U\+[0-9a-f?]{1,6}(-[0-9a-f]{1,6})?/))
+         action {[:UNICODE_RANGE, 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])*'/))
-           @rex_tokens.push action { [:STRING, text] }
+      when (text = @ss.scan(/[\s\t\r\n\f]+/))
+         action { [:S, text] }
 
-        when (text = ss.scan(/./))
-           @rex_tokens.push action { [text, 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])*'/))
+         action { [:STRING, text] }
 
-        else
-          text = ss.string[ss.pos .. -1]
-          raise  ScanError, "can not match: '" + text + "'"
-        end  # if
+      when (text = @ss.scan(/./))
+         action { [text, text] }
 
       else
-        raise  ScanError, "undefined state: '" + state.to_s + "'"
-      end  # case state
-    end  # until ss
-  end  # def scan_evaluate
+        text = @ss.string[@ss.pos .. -1]
+        raise  ScanError, "can not match: '" + text + "'"
+      end  # if
+
+    else
+      raise  ScanError, "undefined state: '" + state.to_s + "'"
+    end  # case state
+    token
+  end  # def next_token
 
 end # class
 end

data/lib/nokogiri/css/tokenizer.rb

@@ -1,11 +1,7 @@
 module Nokogiri
   module CSS
     class Tokenizer < GeneratedTokenizer
-      ###
-      # Scan and tokenize +str+
-      def scan(str)
-        scan_evaluate(str)
-      end
+      alias :scan :scan_setup
     end
   end
 end

data/lib/nokogiri/decorators/hpricot/node_set.rb

@@ -47,7 +47,7 @@ module Nokogiri
             end
           end
           sub_set
-        end          
+        end
       end
     end
   end