nokogiri 1.3.3-x86-mingw32 → 1.4.0-x86-mingw32

data/lib/nokogiri/xml/document_fragment.rb

@@ -3,12 +3,15 @@ module Nokogiri
     class DocumentFragment < Nokogiri::XML::Node
       def initialize document, tags=nil
         if tags
-          parser = if self.kind_of?(Nokogiri::HTML::DocumentFragment)
-                     HTML::SAX::Parser.new(FragmentHandler.new(self, tags))
-                   else
-                     XML::SAX::Parser.new(FragmentHandler.new(self, tags))
-                   end
-          parser.parse(tags)
+          if self.kind_of?(Nokogiri::HTML::DocumentFragment)
+            HTML::SAX::Parser.new(FragmentHandler.new(self, tags)).parse(tags)
+          else
+            wrapped = "<div>#{tags.strip}</div>"
+            XML::SAX::Parser.new(FragmentHandler.new(self, wrapped)).parse(wrapped)
+            div = self.child
+            div.children.each { |child| child.parent = self }
+            div.unlink
+          end
         end
       end
 
@@ -18,22 +21,39 @@ module Nokogiri
         '#document-fragment'
       end
 
+      ###
+      # Convert this DocumentFragment to a string
       def to_s
         children.to_s
       end
 
+      ###
+      # Convert this DocumentFragment to html
+      # See Nokogiri::XML::NodeSet#to_html
       def to_html *args
         children.to_html(*args)
       end
 
+      ###
+      # Convert this DocumentFragment to xhtml
+      # See Nokogiri::XML::NodeSet#to_xhtml
       def to_xhtml *args
         children.to_xhtml(*args)
       end
 
+      ###
+      # Convert this DocumentFragment to xml
+      # See Nokogiri::XML::NodeSet#to_xml
       def to_xml *args
         children.to_xml(*args)
       end
 
+      ###
+      # Search this fragment.  See Nokogiri::XML::Node#css
+      def css *args
+        children.css(*args)
+      end
+
       alias :serialize :to_s
 
       class << self

data/lib/nokogiri/xml/dtd.rb

@@ -1,11 +1,11 @@
 module Nokogiri
   module XML
     class DTD < Nokogiri::XML::Node
-      ###
-      # Return attributes for DTD.  Always returns +nil+
-      def attributes
-        nil
-      end
+      undef_method :attribute_nodes
+      undef_method :content
+      undef_method :namespace
+      undef_method :namespace_definitions
+      undef_method :line
     end
   end
 end

data/lib/nokogiri/xml/element_content.rb

@@ -0,0 +1,36 @@
+module Nokogiri
+  module XML
+    ###
+    # Represents the allowed content in an Element Declaration inside a DTD:
+    #
+    #   <?xml version="1.0"?><?TEST-STYLE PIDATA?>
+    #   <!DOCTYPE staff SYSTEM "staff.dtd" [
+    #      <!ELEMENT div1 (head, (p | list | note)*, div2*)>
+    #   ]>
+    #   </root>
+    #
+    # ElementContent represents the tree inside the <!ELEMENT> tag shown above
+    # that lists the possible content for the div1 tag.
+    class ElementContent
+      # Possible definitions of type
+      PCDATA  = 1
+      ELEMENT = 2
+      SEQ     = 3
+      OR      = 4
+
+      # Possible content occurrences
+      ONCE    = 1
+      OPT     = 2
+      MULT    = 3
+      PLUS    = 4
+
+      attr_reader :document
+
+      ###
+      # Get the children of this ElementContent node
+      def children
+        [c1, c2].compact
+      end
+    end
+  end
+end

data/lib/nokogiri/xml/element_decl.rb

@@ -0,0 +1,13 @@
+module Nokogiri
+  module XML
+    class ElementDecl < Nokogiri::XML::Node
+      undef_method :namespace
+      undef_method :namespace_definitions
+      undef_method :line
+
+      def inspect
+        "#<#{self.class.name}:#{sprintf("0x%x", object_id)} #{to_s.inspect}>"
+      end
+    end
+  end
+end

data/lib/nokogiri/xml/entity_decl.rb

@@ -0,0 +1,15 @@
+module Nokogiri
+  module XML
+    class EntityDecl < Nokogiri::XML::Node
+      undef_method :attribute_nodes
+      undef_method :attributes
+      undef_method :namespace
+      undef_method :namespace_definitions
+      undef_method :line
+
+      def inspect
+        "#<#{self.class.name}:#{sprintf("0x%x", object_id)} #{to_s.inspect}>"
+      end
+    end
+  end
+end

data/lib/nokogiri/xml/fragment_handler.rb

@@ -1,16 +1,14 @@
 module Nokogiri
   module XML
     class FragmentHandler < Nokogiri::XML::SAX::Document # :nodoc:
+      QNAME_REGEX = /(.*):(.*)/
+
       def initialize node, original_html
         @doc_started    = false
         @document       = node.document
         @stack          = [node]
-        @klass          = if node.kind_of?(Nokogiri::HTML::DocumentFragment)
-                            Nokogiri::HTML::DocumentFragment
-                          else
-                            Nokogiri::XML::DocumentFragment
-                          end
-        #
+        @html_eh        = node.kind_of? HTML::DocumentFragment
+
         # the regexes used in start_element() and characters() anchor at
         # start-of-line, but we really only want them to anchor at
         # start-of-doc. so let's only save up to the first newline.
@@ -24,31 +22,44 @@ module Nokogiri
       end
 
       def start_element name, attrs = []
-        regex = (@klass == Nokogiri::HTML::DocumentFragment) ? %r{^\s*<#{Regexp.escape(name)}}i \
-                                                             : %r{^\s*<#{Regexp.escape(name)}}
+        regex = @html_eh ? %r{^\s*<#{Regexp.escape(name)}}i :
+                           %r{^\s*<#{Regexp.escape(name)}}
+
         @doc_started = true if @original_html =~ regex
         return unless @doc_started
 
+        if match = name.match(QNAME_REGEX)
+          prefix, name = match[1], match[2]
+          ns = @document.root.namespace_definitions.detect { |x|
+            x.prefix == prefix
+          }
+        else
+          ns = nil
+        end
+
         node = Element.new(name, @document)
         attrs << "" unless (attrs.length % 2) == 0
         Hash[*attrs].each do |k,v|
           node[k] = v
         end
+
+        node.namespace = ns if ns
+
         @stack.last << node
         @stack << node
       end
 
       def characters string
         @doc_started = true if @original_html.strip =~ %r{^\s*#{Regexp.escape(string.strip)}}
-        @stack.last << Nokogiri::XML::Text.new(string, @document)
+        @stack.last << Text.new(string, @document)
       end
 
       def comment string
-        @stack.last << Nokogiri::XML::Comment.new(@document, string)
+        @stack.last << Comment.new(@document, string)
       end
 
       def cdata_block string
-        @stack.last << Nokogiri::XML::CDATA.new(@document, string)
+        @stack.last << CDATA.new(@document, string)
       end
 
       def end_element name

data/lib/nokogiri/xml/namespace.rb

@@ -1,7 +1,13 @@
 module Nokogiri
   module XML
     class Namespace
+      include Nokogiri::XML::PP::Node
       attr_reader :document
+
+      private
+      def inspect_attributes
+        [:prefix, :href]
+      end
     end
   end
 end

data/lib/nokogiri/xml/node.rb

@@ -34,6 +34,8 @@ module Nokogiri
     #
     # You may search this node's subtree using Node#xpath and Node#css
     class Node
+      include Nokogiri::XML::PP::Node
+
       # Element node type, see Nokogiri::XML::Node#element?
       ELEMENT_NODE =       1
       # Attribute node type
@@ -198,6 +200,24 @@ module Nokogiri
       end
       alias :% :at
 
+      ##
+      # Search this node for the first occurrence of XPath +paths+.
+      # Equivalent to <tt>xpath(paths).first</tt>
+      # See Node#xpath for more information.
+      #
+      def at_xpath *paths
+        xpath(*paths).first
+      end
+
+      ##
+      # Search this node for the first occurrence of CSS +rules+.
+      # Equivalent to <tt>css(rules).first</tt>
+      # See Node#css for more information.
+      #
+      def at_css *rules
+        css(*rules).first
+      end
+
       ###
       # Get the attribute value for the attribute +name+
       def [] name
@@ -388,8 +408,8 @@ module Nokogiri
       end
 
       # Get the inner_html for this node's Node#children
-      def inner_html
-        children.map { |x| x.to_html }.join
+      def inner_html *args
+        children.map { |x| x.to_html(*args) }.join
       end
 
       # Get the path to this node as a CSS expression
@@ -399,14 +419,6 @@ module Nokogiri
         }.compact.join(' > ')
       end
 
-      #  recursively get all namespaces from this node and its subtree
-      def collect_namespaces
-        # TODO: print warning message if a prefix refers to more than one URI in the document?
-        ns = {}
-        traverse {|j| ns.merge!(j.namespaces)}
-        ns
-      end
-
       ###
       # Get a list of ancestor Node for this Node.  If +selector+ is given,
       # the ancestors must match +selector+
@@ -461,7 +473,8 @@ module Nokogiri
       end
 
       ####
-      #  replace this Node with the +new_node+ in the Document.
+      # +replace+ this Node with the +new_node+ in the Document.  The new node
+      # must be a Nokogiri::XML::Node or a non-empty String
       def replace new_node
         if new_node.is_a?(Document) || !new_node.is_a?(XML::Node)
           raise ArgumentError, <<-EOERR
@@ -500,9 +513,11 @@ Node.replace requires a Node argument, and cannot accept a Document.
           :save_with  => args[1] || SaveOptions::FORMAT
         }
 
+        encoding = options[:encoding] || document.encoding
+
         outstring = ""
-        if document.encoding && outstring.respond_to?(:force_encoding)
-          outstring.force_encoding(Encoding.find(document.encoding))
+        if encoding && outstring.respond_to?(:force_encoding)
+          outstring.force_encoding(Encoding.find(encoding))
         end
         io = StringIO.new(outstring)
         write_to io, options, &block
@@ -640,8 +655,11 @@ Node.replace requires a Node argument, and cannot accept a Document.
         return nil unless document == other.document
         compare other
       end
+
+      private
+      def inspect_attributes
+        [:name, :namespace, :attribute_nodes, :children]
+      end
     end
   end
 end
-
-class Nokogiri::XML::Element < Nokogiri::XML::Node ; end

data/lib/nokogiri/xml/node_set.rb

@@ -68,16 +68,21 @@ module Nokogiri
       # For more information see Nokogiri::XML::Node#css and
       # Nokogiri::XML::Node#xpath
       def search *paths
-        ns = paths.last.is_a?(Hash) ? paths.pop :
-          (document.root ? document.root.namespaces : {})
+        handler = ![
+          Hash, String, Symbol
+        ].include?(paths.last.class) ? paths.pop : nil
+
+        ns = paths.last.is_a?(Hash) ? paths.pop : nil
 
         sub_set = NodeSet.new(document)
-        each do |node|
-          paths.each do |path|
-            sub_set +=
-              send(path =~ /^(\.\/|\/)/ ? :xpath : :css, *(paths + [ns]))
-          end
+
+        paths.each do |path|
+          sub_set += send(
+            path =~ /^(\.\/|\/)/ ? :xpath : :css,
+            *(paths + [ns, handler]).compact
+          )
         end
+
         document.decorate(sub_set)
         sub_set
       end
@@ -88,19 +93,26 @@ module Nokogiri
       #
       # For more information see Nokogiri::XML::Node#css
       def css *paths
-        ns = paths.last.is_a?(Hash) ? paths.pop :
-          (document.root ? document.root.namespaces : {})
+        handler = ![
+          Hash, String, Symbol
+        ].include?(paths.last.class) ? paths.pop : nil
+
+        ns = paths.last.is_a?(Hash) ? paths.pop : nil
 
         sub_set = NodeSet.new(document)
 
-        xpaths = paths.map { |rule|
-          [
-            CSS.xpath_for(rule.to_s, :prefix => ".//", :ns => ns),
-            CSS.xpath_for(rule.to_s, :prefix => "self::", :ns => ns)
-          ].join(' | ')
-        }
         each do |node|
-          sub_set += node.xpath(*(xpaths + [ns]))
+          doc = node.document
+          search_ns = ns || doc.root ? doc.root.namespaces : {}
+
+          xpaths = paths.map { |rule|
+            [
+              CSS.xpath_for(rule.to_s, :prefix => ".//", :ns => search_ns),
+              CSS.xpath_for(rule.to_s, :prefix => "self::", :ns => search_ns)
+            ].join(' | ')
+          }
+
+          sub_set += node.xpath(*(xpaths + [search_ns, handler].compact))
         end
         document.decorate(sub_set)
         sub_set
@@ -111,12 +123,15 @@ module Nokogiri
       #
       # For more information see Nokogiri::XML::Node#xpath
       def xpath *paths
-        ns = paths.last.is_a?(Hash) ? paths.pop :
-          (document.root ? document.root.namespaces : {})
+        handler = ![
+          Hash, String, Symbol
+        ].include?(paths.last.class) ? paths.pop : nil
+
+        ns = paths.last.is_a?(Hash) ? paths.pop : nil
 
         sub_set = NodeSet.new(document)
         each do |node|
-          sub_set += node.xpath(*(paths + [ns]))
+          sub_set += node.xpath(*(paths + [ns, handler].compact))
         end
         document.decorate(sub_set)
         sub_set
@@ -135,23 +150,27 @@ module Nokogiri
       # Append the class attribute +name+ to all Node objects in the NodeSet.
       def add_class name
         each do |el|
-          next unless el.respond_to? :get_attribute
-          classes = el.get_attribute('class').to_s.split(" ")
-          el.set_attribute('class', classes.push(name).uniq.join(" "))
+          classes = el['class'].to_s.split(/\s+/)
+          el['class'] = classes.push(name).uniq.join " "
         end
         self
       end
 
       ###
       # Remove the class attribute +name+ from all Node objects in the NodeSet.
+      # If +name+ is nil, remove the class attribute from all Nodes in the
+      # NodeSet.
       def remove_class name = nil
         each do |el|
-          next unless el.respond_to? :get_attribute
           if name
-            classes = el.get_attribute('class').to_s.split(" ")
-            el.set_attribute('class', (classes - [name]).uniq.join(" "))
+            classes = el['class'].to_s.split(/\s+/)
+            if classes.empty?
+              el.delete 'class'
+            else
+              el['class'] = (classes - [name]).uniq.join " "
+            end
           else
-            el.remove_attribute("class")
+            el.delete "class"
           end
         end
         self
@@ -161,28 +180,23 @@ module Nokogiri
       # Set the attribute +key+ to +value+ or the return value of +blk+
       # on all Node objects in the NodeSet.
       def attr key, value = nil, &blk
-        if value or blk
-          each do |el|
-            el.set_attribute(key, value || blk[el])
-          end
-          return self
-        end
-        if key.is_a? Hash
-          key.each { |k,v| self.attr(k,v) }
-          return self
-        else
-          return self[0].get_attribute(key)
+        unless Hash === key || key && (value || blk)
+          return first.attribute(key)
         end
+
+        hash = key.is_a?(Hash) ? key : { key => value }
+
+        hash.each { |k,v| each { |el| el[k] = v || blk[el] } }
+
+        self
       end
-      alias_method :set, :attr
+      alias :set :attr
+      alias :attribute :attr
 
       ###
       # Remove the attributed named +name+ from all Node objects in the NodeSet
       def remove_attr name
-        each do |el|
-          next unless el.respond_to? :remove_attribute
-          el.remove_attribute(name)
-        end
+        each { |el| el.delete name }
         self
       end
 
@@ -212,7 +226,7 @@ module Nokogiri
       def wrap(html, &blk)
         each do |j|
           new_parent = Nokogiri.make(html, &blk)
-          j.parent.add_child(new_parent)
+          j.add_next_sibling(new_parent)
           new_parent.add_child(j)
         end
         self
@@ -275,11 +289,19 @@ module Nokogiri
       end
 
       ###
-      # Returns a new NodeSet containing all the children of all the nodes in the NodeSet
+      # Returns a new NodeSet containing all the children of all the nodes in
+      # the NodeSet
       def children
         inject(NodeSet.new(document)) { |set, node| set += node.children }
       end
 
+      ###
+      # Return a nicely formated string representation
+      def inspect
+        "[#{map { |c| c.inspect }.join ', '}]"
+      end
+
+      alias :+ :|
     end
   end
 end