nokogiri 1.4.1-java → 1.4.2-java

data/lib/nokogiri/xml/entity_decl.rb

@@ -7,6 +7,10 @@ module Nokogiri
       undef_method :namespace_definitions
       undef_method :line
 
+      def self.new name, doc, *args
+        doc.create_entity(name, *args)
+      end
+
       def inspect
         "#<#{self.class.name}:#{sprintf("0x%x", object_id)} #{to_s.inspect}>"
       end

data/lib/nokogiri/xml/node.rb

@@ -35,6 +35,7 @@ module Nokogiri
     # You may search this node's subtree using Node#xpath and Node#css
     class Node
       include Nokogiri::XML::PP::Node
+      include Enumerable
 
       # Element node type, see Nokogiri::XML::Node#element?
       ELEMENT_NODE =       1
@@ -79,7 +80,7 @@ module Nokogiri
       # DOCB document node type
       DOCB_DOCUMENT_NODE = 21
 
-      def initialize name, document
+      def initialize name, document # :nodoc:
         # ... Ya.  This is empty on purpose.
       end
 
@@ -139,15 +140,11 @@ module Nokogiri
         sets = paths.map { |path|
           ctx = XPathContext.new(self)
           ctx.register_namespaces(ns)
-          set = ctx.evaluate(path, handler).node_set
-          set.document = document
-          document.decorate(set)
-          set
+          ctx.evaluate(path, handler)
         }
         return sets.first if sets.length == 1
 
         NodeSet.new(document) do |combined|
-          document.decorate(combined)
           sets.each do |set|
             set.each do |node|
               combined << node
@@ -193,7 +190,7 @@ module Nokogiri
       end
 
       ###
-      # Search this node's immidiate children using CSS selector +selector+
+      # Search this node's immediate children using CSS selector +selector+
       def > selector
         ns = document.root.namespaces
         xpath CSS.xpath_for(selector, :prefix => "./", :ns => ns).first
@@ -201,6 +198,7 @@ module Nokogiri
 
       ###
       # Search for the first occurrence of +path+.
+      #
       # Returns nil if nothing is found, otherwise a Node.
       def at path, ns = document.root ? document.root.namespaces : {}
         search(path, ns).first
@@ -233,46 +231,124 @@ module Nokogiri
       end
 
       ###
-      # Add +node+ as a child of this Node.
-      # The new node must be a Nokogiri::XML::Node or a non-empty String.
+      # 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.
-      def add_child(node)
-        Node.verify_nodeishness(node)
-        if node.type == DOCUMENT_FRAG_NODE
-          node.children.each do |child|
-            add_child_node child
-          end
+      def add_child node_or_tags
+        node_or_tags = coerce(node_or_tags)
+        if node_or_tags.is_a?(XML::NodeSet)
+          node_or_tags.each { |n| add_child_node n }
         else
-          add_child_node node
+          add_child_node node_or_tags
         end
       end
 
       ###
-      # Insert +node+ before this Node (as a sibling).
-      def add_previous_sibling(node)
-        Node.verify_nodeishness(node)
-        if node.type == DOCUMENT_FRAG_NODE
-          node.children.each do |child|
-            add_previous_sibling_node child
-          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.
+      #
+      # 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 }
         else
-          add_previous_sibling_node node
+          add_previous_sibling_node node_or_tags
         end
       end
 
       ###
-      # Insert +node+ after this Node (as a sibling).
-      def add_next_sibling(node)
-        Node.verify_nodeishness(node)
-        if node.type == DOCUMENT_FRAG_NODE
-          node.children.reverse.each do |child|
-            add_next_sibling_node child
+      # 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.
+      #
+      # 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 }
+          else
+            node_or_tags.reverse_each { |n| add_next_sibling_node n }
           end
         else
-          add_next_sibling_node node
+          add_next_sibling_node node_or_tags
+        end
+      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 self, to support chaining of calls.
+      #
+      # Also see related method +add_previous_sibling+.
+      def before node_or_tags
+        add_previous_sibling node_or_tags
+        self
+      end
+
+      ####
+      # Insert +node_or_tags+ after this node (as a sibling).
+      # +node_or_tags+ can be a Nokogiri::XML::Node, a Nokogiri::XML::DocumentFragment, or a string containing markup.
+      #
+      # Returns self, to support chaining of calls.
+      #
+      # Also see related method +add_next_sibling+.
+      def after node_or_tags
+        add_next_sibling node_or_tags
+        self
+      end
+
+      ####
+      # 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.
+      def inner_html= node_or_tags
+        node_or_tags = coerce(node_or_tags)
+        children.unlink
+        if node_or_tags.is_a?(XML::NodeSet)
+          node_or_tags.each { |n| add_child_node n }
+        else
+          add_child node_or_tags
+        end
+        self
+      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.
+      #
+      # 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
+        else
+          replace_node node_or_tags
         end
       end
 
+      ####
+      # Swap this Node for +node_or_tags+
+      # +node_or_tags+ can be a Nokogiri::XML::Node, a ::DocumentFragment, a ::NodeSet, or a string containing markup.
+      #
+      # Returns self, to support chaining of calls.
+      #
+      # Also see related method +replace+.
+      def swap node_or_tags
+        replace node_or_tags
+        self
+      end
+
       alias :next           :next_sibling
       alias :previous       :previous_sibling
 
@@ -295,6 +371,7 @@ module Nokogiri
       alias :type           :node_type
       alias :to_str         :text
       alias :clone          :dup
+      alias :elements       :element_children
 
       ####
       # Returns a hash containing the node's attributes.  The key is
@@ -322,7 +399,7 @@ module Nokogiri
       # Iterate over each attribute name and value pair for this Node.
       def each &block
         attribute_nodes.each { |node|
-          block.call(node.node_name, node.value)
+          block.call([node.node_name, node.value])
         }
       end
 
@@ -339,52 +416,35 @@ module Nokogiri
         ancestors.last.search(selector).include?(self)
       end
 
-      ####
-      # Create nodes from +data+ and insert them before this node
-      # (as a sibling).
-      def before data
-        fragment(data).children.each do |node|
-          add_previous_sibling node
-        end
-        self
+      ###
+      # Create a DocumentFragment containing +tags+ that is relative to _this_
+      # context node.
+      def fragment tags
+        type = document.html? ? Nokogiri::HTML : Nokogiri::XML
+        type::DocumentFragment.new(document, tags, self)
       end
 
-      ####
-      # Create nodes from +data+ and insert them after this node
-      # (as a sibling).
-      def after data
-        fragment(data).children.to_a.reverse.each do |node|
-          add_next_sibling node
+      ###
+      # 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
+        if Fixnum === options
+          options = Nokogiri::XML::ParseOptions.new(options)
         end
-        self
-      end
+        # Give the options to the user
+        yield options if block_given?
 
-      ####
-      # Swap this Node for new nodes made from +data+
-      def swap data
-        before(data)
-        remove
-        self
-      end
-
-      ####
-      # Set the inner_html for this Node to +tags+
-      def inner_html= tags
-        children.each { |x| x.remove}
+        contents = string_or_io.respond_to?(:read) ?
+          string_or_io.read :
+          string_or_io
 
-        fragment(tags).children.to_a.each do |node|
-          add_child node
-        end
-        self
-      end
-
-      def fragment tags # :nodoc:
-        # TODO: deprecate?
-        document.fragment(tags)
+        return Nokogiri::XML::NodeSet.new(document) if contents.empty?
+        in_context(contents, options.to_i)
       end
 
       ####
-      # Set the Node content to +string+.  The content gets XML escaped.
+      # Set the Node's content to a Text node containing +string+. The string gets XML escaped, not interpreted as markup.
       def content= string
         self.native_content = encode_special_chars(string.to_s)
       end
@@ -399,7 +459,7 @@ module Nokogiri
       ###
       # Get a hash containing the Namespace definitions for this Node
       def namespaces
-        Hash[*namespace_definitions.map { |nd|
+        Hash[*namespace_scopes.map { |nd|
           key = ['xmlns', nd.prefix].compact.join(':')
           if RUBY_VERSION >= '1.9' && document.encoding
             begin
@@ -436,6 +496,11 @@ module Nokogiri
         type == TEXT_NODE
       end
 
+      # Returns true if this is a DocumentFragment
+      def fragment?
+        type == DOCUMENT_FRAG_NODE
+      end
+
       ###
       # Fetch the Nokogiri::HTML::ElementDescription for this node.  Returns
       # nil on XML documents and on unknown tags.
@@ -509,12 +574,15 @@ module Nokogiri
       ###
       # Set the namespace for this node to +ns+
       def namespace= ns
+        return set_namespace(ns) unless ns
+
+        unless Nokogiri::XML::Namespace === ns
+          raise TypeError, "#{ns.class} can't be coerced into Nokogiri::XML::Namespace"
+        end
         if ns.document != document
           raise ArgumentError, 'namespace must be declared on the same document'
         end
-        unless ns.is_a? Nokogiri::XML::Namespace
-          raise TypeError, "#{ns.class} can't be coerced into Nokogiri::XML::Namespace"
-        end
+
         set_namespace ns
       end
 
@@ -531,22 +599,6 @@ module Nokogiri
         visitor.visit(self)
       end
 
-      ####
-      # +replace+ this Node with the +node+ in the Document.
-      # The new node must be a Nokogiri::XML::Node or a non-empty String.
-      # Returns the new child node.
-      def replace node
-        Node.verify_nodeishness(node)
-        if node.type == DOCUMENT_FRAG_NODE
-          node.children.each do |child|
-            add_previous_sibling child
-          end
-          unlink
-        else
-          replace_node node
-        end
-      end
-
       ###
       # Test to see if this Node is equal to +other+
       def == other
@@ -612,8 +664,6 @@ module Nokogiri
       #
       # See Node#write_to for a list of +options+
       def to_xml options = {}
-        encoding = nil
-
         options[:save_with] ||= SaveOptions::FORMAT | SaveOptions::AS_XML
 
         serialize(options)
@@ -719,13 +769,20 @@ module Nokogiri
       end
 
       private
-      def self.verify_nodeishness(node)
-        if node.is_a?(Document) || !node.is_a?(XML::Node)
+
+      def coerce(data) # :nodoc:
+        return data                    if data.is_a?(XML::NodeSet)
+        return data.children           if data.is_a?(XML::DocumentFragment)
+        return fragment(data).children if data.is_a?(String)
+
+        if data.is_a?(Document) || !data.is_a?(XML::Node)
           raise ArgumentError, <<-EOERR
-Node.replace requires a Node argument, and cannot accept a Document.
+Requires a Node, NodeSet or String argument, and cannot accept a #{data.class}.
 (You probably want to select a node from the Document with at() or search(), or create a new Node via Node.new().)
           EOERR
         end
+
+        data
       end
 
       def inspect_attributes

data/lib/nokogiri/xml/node_set.rb

@@ -13,6 +13,7 @@ module Nokogiri
       # Create a NodeSet with +document+ defaulting to +list+
       def initialize document, list = []
         @document = document
+        document.decorate(self)
         list.each { |x| self << x }
         yield self if block_given?
       end
@@ -231,7 +232,7 @@ module Nokogiri
       # Wrap this NodeSet with +html+ or the results of the builder in +blk+
       def wrap(html, &blk)
         each do |j|
-          new_parent = Nokogiri.make(html, &blk)
+          new_parent = document.root.parse(html).first
           j.add_next_sibling(new_parent)
           new_parent.add_child(j)
         end

data/lib/nokogiri/xml/sax/push_parser.rb

@@ -42,7 +42,7 @@ module Nokogiri
 
         ###
         # Write a +chunk+ of XML to the PushParser.  Any callback methods
-        # that can be called will be called immidiately.
+        # that can be called will be called immediately.
         def write chunk, last_chunk = false
           native_write(chunk, last_chunk)
         end

data/lib/nokogiri/xml/schema.rb

@@ -43,11 +43,7 @@ module Nokogiri
       # Nokogiri::XML::SyntaxError objects found while validating the
       # +thing+ is returned.
       def validate thing
-        return validate_document(thing) if thing.is_a?(Nokogiri::XML::Document)
-
-        # FIXME libxml2 has an api for validating files.  We should switch
-        # to that because it will probably save memory.
-        validate_document(Nokogiri::XML(File.read(thing)))
+        thing.is_a?(Nokogiri::XML::Document) ? validate_document(thing) : validate_file(thing)
       end
 
       ###

data/lib/nokogiri/xml/syntax_error.rb

@@ -38,6 +38,10 @@ module Nokogiri
       def fatal?
         level == 3
       end
+
+      def to_s
+        super.chomp
+      end
     end
   end
 end

data/lib/nokogiri/xml/text.rb

@@ -0,0 +1,9 @@
+module Nokogiri
+  module XML
+    class Text < Nokogiri::XML::CharacterData
+      def content=(string)
+        self.native_content = string.to_s
+      end
+    end
+  end
+end