nokogiri 1.4.3.1-x86-mingw32 → 1.4.4-x86-mingw32

data/lib/nokogiri/css/generated_tokenizer.rb

@@ -1,6 +1,6 @@
 #--
 # DO NOT MODIFY!!!!
-# This file is automatically generated by rex 1.0.5.beta1
+# This file is automatically generated by rex 1.0.4
 # from lexical definition file "lib/nokogiri/css/tokenizer.rex".
 #++
 
@@ -29,7 +29,6 @@ class GeneratedTokenizer < GeneratedParser
     scan_setup(str)
     do_parse
   end
-  alias :scan :scan_str
 
   def load_file( filename )
     @filename = filename

data/lib/nokogiri/css/xpath_visitor.rb

@@ -11,18 +11,25 @@ module Nokogiri
           'child::text()'
         when /^self\(/
           "self::#{node.value[1]}"
-        when /^(eq|nth|nth-of-type|nth-child)\(/
+        when /^eq\(/
+          "position() = #{node.value[1]}"
+        when /^(nth|nth-of-type|nth-child)\(/
           if node.value[1].is_a?(Nokogiri::CSS::Node) and node.value[1].type == :AN_PLUS_B
             an_plus_b(node.value[1])
           else
-            "position() = " + node.value[1]
+            "position() = #{node.value[1]}"
+          end
+        when /^(nth-last-child|nth-last-of-type)\(/
+          if node.value[1].is_a?(Nokogiri::CSS::Node) and node.value[1].type == :AN_PLUS_B
+            an_plus_b(node.value[1], :last => true)
+          else
+            index = node.value[1].to_i - 1
+            index == 0 ? "position() = last()" : "position() = last() - #{index}"
           end
         when /^(first|first-of-type)\(/
           "position() = 1"
         when /^(last|last-of-type)\(/
           "position() = last()"
-        when /^(nth-last-child|nth-last-of-type)\(/
-          "position() = last() - #{node.value[1]}"
         when /^contains\(/
           "contains(., #{node.value[1]})"
         when /^gt\(/
@@ -144,17 +151,18 @@ module Nokogiri
       end
 
     private
-      def an_plus_b node
+      def an_plus_b node, options={}
         raise ArgumentError, "expected an+b node to contain 4 tokens, but is #{node.value.inspect}" unless node.value.size == 4
 
         a = node.value[0].to_i
         b = node.value[3].to_i
+        position = options[:last] ? "(last()-position()+1)" : "position()"
 
         if (b == 0)
-          return "(position() mod #{a}) = 0"
+          return "(#{position} mod #{a}) = 0"
         else
           compare = (a < 0) ? "<=" : ">="
-          return "(position() #{compare} #{b}) and (((position()-#{b}) mod #{a.abs}) = 0)"
+          return "(#{position} #{compare} #{b}) and (((#{position}-#{b}) mod #{a.abs}) = 0)"
         end
       end
 

data/lib/nokogiri/decorators/slop.rb

@@ -7,20 +7,22 @@ module Nokogiri
       ###
       # look for node with +name+.  See Nokogiri.Slop
       def method_missing name, *args, &block
+        prefix = implied_xpath_context
+
         if args.empty?
-          list = xpath("./#{name}")
+          list = xpath("#{prefix}#{name.to_s.sub(/^_/, '')}")
         elsif args.first.is_a? Hash
           hash = args.first
           if hash[:css]
             list = css("#{name}#{hash[:css]}")
           elsif hash[:xpath]
             conds = Array(hash[:xpath]).join(' and ')
-            list = xpath("./#{name}[#{conds}]")
+            list = xpath("#{prefix}#{name}[#{conds}]")
           end
         else
           CSS::Parser.without_cache do
             list = xpath(
-              *CSS.xpath_for("#{name}#{args.first}", :prefix => "./")
+              *CSS.xpath_for("#{name}#{args.first}", :prefix => prefix)
             )
           end
         end

data/lib/nokogiri/ffi/libxml.rb

@@ -62,6 +62,9 @@ module Nokogiri
     callback :cdata_block_sax_func, [:pointer, :string, :int], :void
     callback :start_element_ns_sax2_func, [:pointer, :pointer, :pointer, :pointer, :int, :pointer, :int, :int, :pointer], :void
     callback :end_element_ns_sax2_func, [:pointer, :pointer, :pointer, :pointer], :void
+    callback :xslt_function_init, [:pointer, :string], :pointer
+    callback :xslt_function_shutdown, [:pointer, :string, :pointer], :void
+    callback :xslt_function_caller, [:pointer, :int], :void
 
     # encoding.c
     attach_function :xmlFindCharEncodingHandler, [:string], :pointer
@@ -200,6 +203,8 @@ module Nokogiri
     attach_function :xmlXPathWrapString, [:pointer], :pointer # should take a :string, but we optimize
     attach_function :xmlXPathNewBoolean, [:int], :pointer
     attach_function :xmlXPathNewFloat, [:double], :pointer
+    attach_function :xmlXPathNewCString, [:string], :pointer
+    attach_function :xmlXPathRegisterVariable, [:pointer, :string, :pointer], :int
 
     class << self
       # these functions are implemented as C macros
@@ -272,6 +277,9 @@ module Nokogiri
     attach_function :xsltApplyStylesheet, [:pointer, :pointer, :pointer], :pointer
     attach_function :xsltSaveResultToString, [:buffer_out, :buffer_out, :pointer, :pointer], :int
     attach_function :xsltSetGenericErrorFunc, [:pointer, :generic_error_handler], :void
+    attach_function :xsltRegisterExtModule, [:string, :xslt_function_init, :xslt_function_shutdown], :int
+    attach_function :xsltRegisterExtFunction, [:pointer, :string, :string, :xslt_function_caller], :int
+    attach_function :xsltXPathGetTransformContext, [:pointer], :pointer
 
     # exslt.c
     attach_function :exsltRegisterAll, [], :void
@@ -376,6 +384,7 @@ require 'nokogiri/xml/syntax_error'
   "structs/xml_element",
   "structs/xml_entity",
   "structs/xml_element_content",
+  "structs/xml_parser_input",
   "xml/node",
   "xml/namespace",
   "xml/dtd",

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

@@ -11,7 +11,8 @@ module Nokogiri
         :version,           :string,
         :encoding,          :string,
         :standalone,        :int,
-        :html,              :int
+        :html,              :int,
+        :input,             :pointer
       )
     end
   end

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

@@ -0,0 +1,19 @@
+module Nokogiri
+  # :stopdoc:
+  module LibXML
+    class XmlParserInput < FFI::Struct
+      layout(
+        :buf,               :pointer,
+        :filename,          :pointer,
+        :directory,         :pointer,
+        :base,              :pointer,
+        :cur,               :pointer,
+        :end,               :pointer,
+        :length,            :int,
+        :line,              :int,
+        :col,               :int
+      )
+    end
+  end
+  # :startdoc:
+end

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

@@ -53,9 +53,9 @@ module Nokogiri
 
       def internal_attributes attr_name
         attr_ptr = cstruct[attr_name.to_sym]
-        return nil if attr_ptr.null?
-
         ahash = {}
+        return ahash if attr_ptr.null?
+
         LibXML.xmlHashScan(attr_ptr, nil) do |payload, data, name|
           ahash[name] = Node.wrap(payload)
         end

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

@@ -405,17 +405,22 @@ module Nokogiri
       end
 
       def in_context(string, options)
-        raise RuntimeError, "no contextual parsing on unlinked nodes" if parent.nil?
-
-        @errors = []
-        LibXML.xmlSetStructuredErrorFunc(nil, SyntaxError.error_array_pusher(@errors))
+        errors = []
+        LibXML.xmlSetStructuredErrorFunc(nil, SyntaxError.error_array_pusher(errors))
         LibXML.htmlHandleOmittedElem(0)
 
         list_memory = FFI::MemoryPointer.new :pointer
         LibXML.xmlParseInNodeContext(cstruct, string, string.length, options, list_memory)
 
+        self.document.children.each do |child|
+          if child.cstruct[:parent] != cstruct[:doc]
+            child.cstruct[:parent] = cstruct[:doc]
+          end
+        end
+
         LibXML.htmlHandleOmittedElem(1)
         LibXML.xmlSetStructuredErrorFunc(nil, nil)
+        self.document.errors = errors
 
         set = NodeSet.wrap(LibXML.xmlXPathNodeSetCreate(nil), document)
         list_ptr = list_memory.get_pointer(0)

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

@@ -40,6 +40,18 @@ module Nokogiri
           pc
         end
 
+        def line
+          return nil if cstruct[:input].null?
+          input = LibXML::XmlParserInput.new cstruct[:input]
+          input[:line]
+        end
+
+        def column
+          return nil if cstruct[:input].null?
+          input = LibXML::XmlParserInput.new cstruct[:input]
+          input[:col]
+        end
+
         def parse_with sax_handler, type = :xml
           raise ArgumentError unless XML::SAX::Parser === sax_handler
           sax = sax_handler.cstruct

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

@@ -8,6 +8,11 @@ module Nokogiri
         LibXML.xmlXPathRegisterNs(cstruct, prefix, uri)
       end
 
+      def register_variable(name, value) # :nodoc:
+        xml_value = LibXML.xmlXPathNewCString(value);
+        LibXML.xmlXPathRegisterVariable(cstruct, name, xml_value);
+      end
+
       def evaluate(search_path, xpath_handler=nil) # :nodoc:
         lookup = nil # to keep lambda in scope long enough to avoid a possible GC tragedy
         query = search_path.to_s

data/lib/nokogiri/ffi/xslt/stylesheet.rb

@@ -1,5 +1,26 @@
 module Nokogiri
   module XSLT
+    @modules = {}
+
+    @method_caller = lambda do |context, nargs|
+      # TODO
+    end
+
+    @init_func = lambda do |context, uri|
+      klass = @modules[uri]
+      klass.instance_methods(false).each do |method_name|
+	LibXML.xsltRegisterExtFunction(context, method_name, uri, @method_caller)
+      end
+      klass.new
+    end
+
+    @shutdown_func = lambda do |context, uri, data|
+    end
+
+    def self.register(uri, klass) # :nodoc:
+      raise NotImplementedError.new("sorry, you should implement me.")
+    end
+
     class Stylesheet
 
       attr_accessor :cstruct # :nodoc:
@@ -47,7 +68,6 @@ module Nokogiri
 
         XML::Document.wrap(ptr)
       end
-
     end
   end
 end

data/lib/nokogiri/html/document.rb

@@ -13,7 +13,7 @@ module Nokogiri
       end
 
       ###
-      # Set the meta tag encoding for this document.  If there is no meta 
+      # Set the meta tag encoding for this document.  If there is no meta
       # content tag, nil is returned and the encoding is not set.
       def meta_encoding= encoding
         return nil unless meta = css('meta').find { |node|
@@ -38,7 +38,7 @@ module Nokogiri
       #     config.format.as_xml
       #   end
       #
-      def serialize options = {}, &block
+      def serialize options = {}
         options[:save_with] ||= XML::Node::SaveOptions::FORMAT |
             XML::Node::SaveOptions::AS_HTML |
             XML::Node::SaveOptions::NO_DECLARATION |
@@ -61,7 +61,7 @@ module Nokogiri
         # is a number that sets options in the parser, such as
         # 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
+        def parse string_or_io, url = nil, encoding = nil, options = XML::ParseOptions::DEFAULT_HTML
 
           options = Nokogiri::XML::ParseOptions.new(options) if Fixnum === options
           # Give the options to the user

data/lib/nokogiri/html/document_fragment.rb

@@ -1,6 +1,8 @@
 module Nokogiri
   module HTML
     class DocumentFragment < Nokogiri::XML::DocumentFragment
+      attr_accessor :errors
+
       ####
       # Create a Nokogiri::XML::DocumentFragment from +tags+, using +encoding+
       def self.parse tags, encoding = nil
@@ -15,24 +17,24 @@ module Nokogiri
       def initialize document, tags = nil, ctx = nil
         return self unless tags
 
-        children = if ctx
-                     ctx.parse("<div>#{tags.strip}</div>").first.children
-                   else
-                     ###
-                     # This is a horrible hack, but I don't care
-                     if tags.strip =~ /^<body/i
-                       path = "/html/body"
-                     else
-                       path = "/html/body/node()"
-                     end
+        if ctx
+          preexisting_errors = document.errors.dup
+          node_set = ctx.parse("<div>#{tags}</div>")
+          node_set.first.children.each { |child| child.parent = self } unless node_set.empty?
+          self.errors = document.errors - preexisting_errors
+        else
+          # This is a horrible hack, but I don't care
+          if tags.strip =~ /^<body/i
+            path = "/html/body"
+          else
+            path = "/html/body/node()"
+          end
 
-                     HTML::Document.parse(
-                       "<html><body>#{tags.strip}</body></html>",
-                       nil,
-                       document.encoding
-                     ).xpath(path)
-                   end
-        children.each { |child| child.parent = self }
+          temp_doc = HTML::Document.parse "<html><body>#{tags}", nil, document.encoding
+          temp_doc.xpath(path).each { |child| child.parent = self }
+          self.errors = temp_doc.errors
+        end
+        children
       end
     end
   end

data/lib/nokogiri/version.rb

@@ -1,6 +1,6 @@
 module Nokogiri
   # The version of Nokogiri you are using
-  VERSION = '1.4.3.1'
+  VERSION = '1.4.4'
 
   # More complete version information about libxml
   VERSION_INFO = {}

data/lib/nokogiri/xml/document.rb

@@ -113,6 +113,13 @@ module Nokogiri
       #   </root>
       #
       # The hash returned will look like this: { 'xmlns:foo' => 'bar' }
+      #
+      # Non-prefixed default namespaces (as in "xmlns=") are not included
+      # in the hash.
+      #
+      # Note this is a very expensive operation in current implementation, as it
+      # traverses the entire graph, and also has to bring each node accross the
+      # libxml bridge into a ruby object.
       def collect_namespaces
         ns = {}
         traverse { |j| ns.merge!(j.namespaces) }
@@ -134,7 +141,21 @@ module Nokogiri
       end
 
       ##
-      # Explore a document with shortcut methods.
+      # Explore a document with shortcut methods. See Nokogiri::Slop for details.
+      #
+      # Note that any nodes that have been instantiated before #slop!
+      # is called will not be decorated with sloppy behavior. So, if you're in
+      # irb, the preferred idiom is:
+      #
+      #   irb> doc = Nokogiri::Slop my_markup
+      #
+      # and not
+      #
+      #   irb> doc = Nokogiri::HTML my_markup
+      #   ... followed by irb's implicit inspect (and therefore instantiation of every node) ...
+      #   irb> doc.slop!
+      #   ... which does absolutely nothing.
+      #
       def slop!
         unless decorators(XML::Node).include? Nokogiri::Decorators::Slop
           decorators(XML::Node) << Nokogiri::Decorators::Slop
@@ -185,6 +206,10 @@ module Nokogiri
       alias :<< :add_child
 
       private
+      def implied_xpath_context
+        "/"
+      end
+
       def inspect_attributes
         [:name, :children]
       end

data/lib/nokogiri/xml/document_fragment.rb

@@ -11,9 +11,9 @@ module Nokogiri
         return self unless tags
 
         children = if ctx
-                     ctx.parse(tags.strip)
+                     ctx.parse(tags)
                    else
-                     XML::Document.parse("<root>#{tags.strip}</root>") \
+                     XML::Document.parse("<root>#{tags}</root>") \
                        .xpath("/root/node()")
                    end
         children.each { |child| child.parent = self }

data/lib/nokogiri/xml/dtd.rb

@@ -2,10 +2,21 @@ module Nokogiri
   module XML
     class DTD < Nokogiri::XML::Node
       undef_method :attribute_nodes
+      undef_method :values
       undef_method :content
       undef_method :namespace
       undef_method :namespace_definitions
       undef_method :line
+
+      def keys
+        attributes.keys
+      end
+
+      def each &block
+        attributes.each { |key, value|
+          block.call([key, value])
+        }
+      end
     end
   end
 end

data/lib/nokogiri/xml/node.rb

@@ -95,13 +95,17 @@ module Nokogiri
       # optional hash of namespaces may be appended.
       # See Node#xpath and Node#css.
       def search *paths
+        # TODO use         paths, handler, ns, binds = extract_params(paths)
         ns = paths.last.is_a?(Hash) ? paths.pop :
           (document.root ? document.root.namespaces : {})
+
+        prefix = "#{implied_xpath_context}/"
+
         xpath(*(paths.map { |path|
           path = path.to_s
           path =~ /^(\.\/|\/)/ ? path : CSS.xpath_for(
             path,
-            :prefix => ".//",
+            :prefix => prefix,
             :ns     => ns
           )
         }.flatten.uniq) + [ns])
@@ -109,16 +113,28 @@ module Nokogiri
       alias :/ :search
 
       ###
+      # call-seq: xpath *paths, [namespace-bindings, variable-bindings, custom-handler-class]
+      #
       # Search this node for XPath +paths+. +paths+ must be one or more XPath
-      # queries.  A hash of namespaces may be appended.  For example:
+      # queries.
       #
       #   node.xpath('.//title')
-      #   node.xpath('.//foo:name', { 'foo' => 'http://example.org/' })
+      #
+      # A hash of namespace bindings may be appended. For example:
+      #
+      #   node.xpath('.//foo:name', {'foo' => 'http://example.org/'})
       #   node.xpath('.//xmlns:name', node.root.namespaces)
       #
-      # Custom XPath functions may also be defined.  To define custom functions
-      # create a class and implement the # function you want to define.
-      # For example:
+      # A hash of variable bindings may also be appended to the namespace bindings. For example:
+      #
+      #   node.xpath('.//address[@domestic=$value]', nil, {:value => 'Yes'})
+      #
+      # Custom XPath functions may also be defined.  To define custom
+      # functions create a class and implement the function you want
+      # to define.  The first argument to the method will be the
+      # current matching NodeSet.  Any other arguments are ones that
+      # you pass in.  Note that this class may appear anywhere in the
+      # argument list.  For example:
       #
       #   node.xpath('.//title[regex(., "\w+")]', Class.new {
       #     def regex node_set, regex
@@ -127,19 +143,18 @@ module Nokogiri
       #   }.new)
       #
       def xpath *paths
-        # Pop off our custom function handler if it exists
-        handler = ![
-          Hash, String, Symbol
-        ].include?(paths.last.class) ? paths.pop : nil
-
-        ns = paths.last.is_a?(Hash) ? paths.pop :
-          (document.root ? document.root.namespaces : {})
-
         return NodeSet.new(document) unless document
 
+        paths, handler, ns, binds = extract_params(paths)
+
         sets = paths.map { |path|
           ctx = XPathContext.new(self)
           ctx.register_namespaces(ns)
+
+          binds.each do |key,value|
+            ctx.register_variable key.to_s, value
+          end if binds
+
           ctx.evaluate(path, handler)
         }
         return sets.first if sets.length == 1
@@ -154,18 +169,24 @@ module Nokogiri
       end
 
       ###
+      # call-seq: css *rules, [namespace-bindings, custom-pseudo-class]
+      #
       # Search this node for CSS +rules+. +rules+ must be one or more CSS
-      # selectors.  For example:
+      # selectors. For example:
       #
       #   node.css('title')
       #   node.css('body h1.bold')
       #   node.css('div + p.green', 'div#one')
       #
-      # Custom CSS pseudo classes may also be defined.  To define custom pseudo
-      # classes, create a class and implement the custom pseudo class you
-      # want defined.  The first argument to the method will be the current
-      # matching NodeSet.  Any other arguments are ones that you pass in.
-      # For example:
+      # A hash of namespace bindings may be appended. For example:
+      #
+      #   node.css('bike|tire', {'bike' => 'http://schwinn.com/'})
+      #
+      # Custom CSS pseudo classes may also be defined.  To define
+      # custom pseudo classes, create a class and implement the custom
+      # pseudo class you want defined.  The first argument to the
+      # method will be the current matching NodeSet.  Any other
+      # arguments are ones that you pass in.  For example:
       #
       #   node.css('title:regex("\w+")', Class.new {
       #     def regex node_set, regex
@@ -173,18 +194,21 @@ module Nokogiri
       #     end
       #   }.new)
       #
+      # Note that the CSS query string is case-sensitive with regards
+      # to your document type. That is, if you're looking for "H1" in
+      # an HTML document, you'll never find anything, since HTML tags
+      # will match only lowercase CSS queries. However, "H1" might be
+      # found in an XML document, where tags names are case-sensitive
+      # (e.g., "H1" is distinct from "h1").
+      #
       def css *rules
-        # Pop off our custom function handler if it exists
-        handler = ![
-          Hash, String, Symbol
-        ].include?(rules.last.class) ? rules.pop : nil
+        rules, handler, ns, binds = extract_params(rules)
 
-        ns = rules.last.is_a?(Hash) ? rules.pop :
-          (document.root ? document.root.namespaces : {})
+        prefix = "#{implied_xpath_context}/"
 
         rules = rules.map { |rule|
-          CSS.xpath_for(rule, :prefix => ".//", :ns => ns)
-        }.flatten.uniq + [ns, handler].compact
+          CSS.xpath_for(rule, :prefix => prefix, :ns => ns)
+        }.flatten.uniq + [ns, handler, binds].compact
 
         xpath(*rules)
       end
@@ -234,7 +258,7 @@ module Nokogiri
       # Add +node_or_tags+ as a child of this Node.
       # +node_or_tags+ can be a Nokogiri::XML::Node, a ::DocumentFragment, a ::NodeSet, or a string containing markup.
       #
-      # Returns the new child node.
+      # Returns the reparented node (if +node_or_tags+ is a Node), or NodeSet (if +node_or_tags+ is a DocumentFragment, NodeSet, or string).
       def add_child node_or_tags
         node_or_tags = coerce(node_or_tags)
         if node_or_tags.is_a?(XML::NodeSet)
@@ -242,42 +266,55 @@ module Nokogiri
         else
           add_child_node node_or_tags
         end
+        node_or_tags
       end
 
       ###
       # Insert +node_or_tags+ before this Node (as a sibling).
       # +node_or_tags+ can be a Nokogiri::XML::Node, a ::DocumentFragment, a ::NodeSet, or a string containing markup.
       #
-      # Returns the new sibling node.
+      # Returns the reparented node (if +node_or_tags+ is a Node), or NodeSet (if +node_or_tags+ is a DocumentFragment, NodeSet, or string).
       #
       # Also see related method +before+.
       def add_previous_sibling node_or_tags
         node_or_tags = coerce(node_or_tags)
         if node_or_tags.is_a?(XML::NodeSet)
-          node_or_tags.each { |n| add_previous_sibling_node n }
+          if text?
+            pivot = Nokogiri::XML::Node.new 'dummy', document
+            add_previous_sibling_node pivot
+          else
+            pivot = self
+          end
+          node_or_tags.each { |n| pivot.send :add_previous_sibling_node, n }
+          pivot.unlink if text?
         else
           add_previous_sibling_node node_or_tags
         end
+        node_or_tags
       end
 
       ###
       # Insert +node_or_tags+ after this Node (as a sibling).
       # +node_or_tags+ can be a Nokogiri::XML::Node, a ::DocumentFragment, a ::NodeSet, or a string containing markup.
       #
-      # Returns the new sibling node.
+      # Returns the reparented node (if +node_or_tags+ is a Node), or NodeSet (if +node_or_tags+ is a DocumentFragment, NodeSet, or string).
       #
       # Also see related method +after+.
       def add_next_sibling node_or_tags
         node_or_tags = coerce(node_or_tags)
         if node_or_tags.is_a?(XML::NodeSet)
-          if '1.8.6' == RUBY_VERSION
-            node_or_tags.reverse.each { |n| add_next_sibling_node n }
+          if text?
+            pivot = Nokogiri::XML::Node.new 'dummy', document
+            add_next_sibling_node pivot
           else
-            node_or_tags.reverse_each { |n| add_next_sibling_node n }
+            pivot = self
           end
+          node_or_tags.reverse.each { |n| pivot.send :add_next_sibling_node, n }
+          pivot.unlink if text?
         else
           add_next_sibling_node node_or_tags
         end
+        node_or_tags
       end
 
       ####
@@ -305,11 +342,25 @@ module Nokogiri
       end
 
       ####
-      # Set the inner_html for this Node to +node_or_tags+
+      # Set the inner html for this Node to +node_or_tags+
       # +node_or_tags+ can be a Nokogiri::XML::Node, a Nokogiri::XML::DocumentFragment, or a string containing markup.
       #
       # Returns self.
+      #
+      # Also see related method +children=+
       def inner_html= node_or_tags
+        self.children = node_or_tags
+        self
+      end
+
+      ####
+      # Set the inner html for this Node +node_or_tags+
+      # +node_or_tags+ can be a Nokogiri::XML::Node, a Nokogiri::XML::DocumentFragment, or a string containing markup.
+      #
+      # Returns the reparented node (if +node_or_tags+ is a Node), or NodeSet (if +node_or_tags+ is a DocumentFragment, NodeSet, or string).
+      #
+      # Also see related method +inner_html=+
+      def children= node_or_tags
         node_or_tags = coerce(node_or_tags)
         children.unlink
         if node_or_tags.is_a?(XML::NodeSet)
@@ -317,24 +368,32 @@ module Nokogiri
         else
           add_child node_or_tags
         end
-        self
+        node_or_tags
       end
 
       ####
       # Replace this Node with +node_or_tags+.
       # +node_or_tags+ can be a Nokogiri::XML::Node, a ::DocumentFragment, a ::NodeSet, or a string containing markup.
       #
-      # Returns the new child node.
+      # Returns the reparented node (if +node_or_tags+ is a Node), or NodeSet (if +node_or_tags+ is a DocumentFragment, NodeSet, or string).
       #
       # Also see related method +swap+.
       def replace node_or_tags
         node_or_tags = coerce(node_or_tags)
         if node_or_tags.is_a?(XML::NodeSet)
-          node_or_tags.each { |n| add_previous_sibling n }
-          unlink
+          if text?
+            replacee = Nokogiri::XML::Node.new 'dummy', document
+            add_previous_sibling_node replacee
+            unlink
+          else
+            replacee = self
+          end
+          node_or_tags.each { |n| replacee.add_previous_sibling n }
+          replacee.unlink
         else
           replace_node node_or_tags
         end
+        node_or_tags
       end
 
       ####
@@ -430,7 +489,8 @@ module Nokogiri
       # Parse +string_or_io+ as a document fragment within the context of
       # *this* node.  Returns a XML::NodeSet containing the nodes parsed from
       # +string_or_io+.
-      def parse string_or_io, options = ParseOptions::DEFAULT_XML
+      def parse string_or_io, options = nil
+        options ||= (document.html? ? ParseOptions::DEFAULT_HTML : ParseOptions::DEFAULT_XML)
         if Fixnum === options
           options = Nokogiri::XML::ParseOptions.new(options)
         end
@@ -442,7 +502,16 @@ module Nokogiri
           string_or_io
 
         return Nokogiri::XML::NodeSet.new(document) if contents.empty?
-        in_context(contents, options.to_i)
+
+        ##
+        # This is a horrible hack, but I don't care. See #313 for background.
+        error_count = document.errors.length
+        node_set = in_context(contents, options.to_i)
+        if node_set.empty? and document.errors.length > error_count and options.recover?
+          fragment = Nokogiri::HTML::DocumentFragment.parse contents
+          node_set = fragment.children
+        end
+        node_set
       end
 
       ####
@@ -459,7 +528,19 @@ module Nokogiri
       end
 
       ###
-      # Get a hash containing the Namespace definitions for this Node
+      # Returns a Hash of {prefix => value} for all namespaces on this
+      # node and its ancestors.
+      #
+      # This method returns the same namespaces as #namespace_scopes.
+      #
+      # Returns namespaces in scope for self -- those defined on self
+      # element directly or any ancestor node -- as a Hash of
+      # attribute-name/value pairs. Note that the keys in this hash
+      # XML attributes that would be used to define this namespace,
+      # such as "xmlns:prefix", not just the prefix. Default namespace
+      # set on self will be included with key "xmlns". However,
+      # default namespaces set on ancestor will NOT be, even if self
+      # has no explicit default namespace.
       def namespaces
         Hash[*namespace_scopes.map { |nd|
           key = ['xmlns', nd.prefix].compact.join(':')
@@ -567,14 +648,22 @@ module Nokogiri
       end
 
       ###
-      # Set the default namespace for this node to +url+
+      # Adds a default namespace supplied as a string +url+ href, to self.
+      # The consequence is as an xmlns attribute with supplied argument were
+      # present in parsed XML.  A default namespace set with this method will
+      # now show up in #attributes, but when this node is serialized to XML an
+      # "xmlns" attribute will appear. See also #namespace and #namespace=
       def default_namespace= url
         add_namespace_definition(nil, url)
       end
       alias :add_namespace :add_namespace_definition
 
       ###
-      # Set the namespace for this node to +ns+
+      # Set the default namespace on this node (as would be defined with an
+      # "xmlns=" attribute in XML source), as a Namespace object +ns+. Note that
+      # a Namespace added this way will NOT be serialized as an xmlns attribute
+      # for this node. You probably want #default_namespace= instead, or perhaps
+      # #add_namespace_definition with a nil prefix argument.
       def namespace= ns
         return set_namespace(ns) unless ns
 
@@ -772,6 +861,24 @@ module Nokogiri
 
       private
 
+      def extract_params params # :nodoc:
+        # Pop off our custom function handler if it exists
+        handler = params.find { |param|
+          ![Hash, String, Symbol].include?(param.class)
+        }
+
+        params -= [handler] if handler
+
+        hashes = []
+        hashes << params.pop while Hash === params.last || params.last.nil?
+
+        ns, binds = hashes.reverse
+
+        ns ||= document.root ? document.root.namespaces : {}
+
+        [params, handler, ns, binds]
+      end
+
       def coerce data # :nodoc:
         return data                    if data.is_a?(XML::NodeSet)
         return data.children           if data.is_a?(XML::DocumentFragment)
@@ -787,6 +894,10 @@ Requires a Node, NodeSet or String argument, and cannot accept a #{data.class}.
         data
       end
 
+      def implied_xpath_context
+        "./"
+      end
+
       def inspect_attributes
         [:name, :namespace, :attribute_nodes, :children]
       end