nokogiri 1.1.1-java

data/lib/nokogiri/xml/dtd.rb

@@ -0,0 +1,6 @@
+module Nokogiri
+  module XML
+    class DTD < Node
+    end
+  end
+end

data/lib/nokogiri/xml/element.rb

@@ -0,0 +1,6 @@
+module Nokogiri
+  module XML
+    class Element < Node
+    end
+  end
+end

data/lib/nokogiri/xml/entity_declaration.rb

@@ -0,0 +1,9 @@
+module Nokogiri
+  module XML
+    class EntityDeclaration < Node
+      def attributes
+        nil
+      end
+    end
+  end
+end

data/lib/nokogiri/xml/node.rb

@@ -0,0 +1,333 @@
+module Nokogiri
+  module XML
+    class Node
+      ELEMENT_NODE =       1
+      ATTRIBUTE_NODE =     2
+      TEXT_NODE =          3
+      CDATA_SECTION_NODE = 4
+      ENTITY_REF_NODE =    5
+      ENTITY_NODE =        6
+      PI_NODE =            7
+      COMMENT_NODE =       8
+      DOCUMENT_NODE =      9
+      DOCUMENT_TYPE_NODE = 10
+      DOCUMENT_FRAG_NODE = 11
+      NOTATION_NODE =      12
+      HTML_DOCUMENT_NODE = 13
+      DTD_NODE =           14
+      ELEMENT_DECL =       15
+      ATTRIBUTE_DECL =     16
+      ENTITY_DECL =        17
+      NAMESPACE_DECL =     18
+      XINCLUDE_START =     19
+      XINCLUDE_END =       20
+      DOCB_DOCUMENT_NODE = 21
+
+      attr_accessor :document
+
+      ###
+      # Decorate this node with the decorators set up in this node's Document
+      def decorate!
+        document.decorate(self) if document
+      end
+
+      ###
+      # Get the list of children for this node as a NodeSet
+      def children
+        list = NodeSet.new(document)
+        document.decorate(list)
+
+        first = self.child
+        return list unless first # Empty list
+
+        list << first
+        while first = first.next
+          list << first
+        end
+        list
+      end
+
+      ###
+      # Search this node for +paths+.  +paths+ can be XPath or CSS, and an
+      # optional hash of namespaces may be appended.
+      # See Node#xpath and Node#css.
+      def search *paths
+        ns = paths.last.is_a?(Hash) ? paths.pop : {}
+        xpath(*(paths.map { |path|
+          path = path.to_s
+          path =~ /^(\.\/|\/)/ ? path : CSS.xpath_for(path, :prefix => ".//")
+        }.flatten.uniq) + [ns])
+      end
+      alias :/ :search
+
+      ###
+      # Search this node for XPath +paths+. +paths+ must be one or more XPath
+      # queries.  A hash of namespaces may be appended.  For example:
+      #
+      #   node.xpath('.//title')
+      #   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:
+      #
+      #   node.xpath('.//title[regex(., "\w+")]', Class.new {
+      #     def regex node_set, regex
+      #       node_set.find_all { |node| node['some_attribute'] =~ /#{regex}/ }
+      #     end
+      #   })
+      #
+      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 : {}
+
+        return NodeSet.new(document) unless document.root
+
+        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
+        }
+        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
+            end
+          end
+        end
+      end
+
+      ###
+      # Search this node for CSS +rules+. +rules+ must be one or more CSS
+      # 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:
+      #
+      #   node.css('title:regex("\w+")', Class.new {
+      #     def regex node_set, regex
+      #       node_set.find_all { |node| node['some_attribute'] =~ /#{regex}/ }
+      #     end
+      #   })
+      #
+      def css *rules
+        # Pop off our custom function handler if it exists
+        handler = ![
+          Hash, String, Symbol
+        ].include?(rules.last.class) ? rules.pop : nil
+
+        ns = rules.last.is_a?(Hash) ? rules.pop : {}
+
+        rules = rules.map { |rule|
+          CSS.xpath_for(rule, :prefix => ".//")
+        }.flatten.uniq + [ns, handler].compact
+
+        xpath(*rules)
+      end
+
+      def at path, ns = {}
+        search(path, ns).first
+      end
+
+      def [](property)
+        return nil unless key?(property)
+        get(property)
+      end
+
+      def next
+        next_sibling
+      end
+
+      def previous
+        previous_sibling
+      end
+
+      def remove
+        unlink
+      end
+
+      ####
+      # Returns a hash containing the node's attributes.  The key is the
+      # attribute name, the value is the string value of the attribute.
+      def attributes
+        Hash[*(attribute_nodes.map { |node|
+          [node.name, node]
+        }.flatten)]
+      end
+
+      ###
+      # Remove the attribute named +name+
+      def remove_attribute name
+        attributes[name].remove if key? name
+      end
+      alias :delete :remove_attribute
+
+      ####
+      # Create nodes from +data+ and insert them before this node
+      # (as a sibling).
+      def before data
+        classes = document.class.name.split('::')
+        classes[-1] = 'SAX::Parser'
+
+        parser = eval(classes.join('::')).new(BeforeHandler.new(self, data))
+        parser.parse(data)
+      end
+
+      ####
+      # Create nodes from +data+ and insert them after this node
+      # (as a sibling).
+      def after data
+        classes = document.class.name.split('::')
+        classes[-1] = 'SAX::Parser'
+
+        handler = AfterHandler.new(self, data)
+        parser = eval(classes.join('::')).new(handler)
+        parser.parse(data)
+        handler.after_nodes.reverse.each do |sibling|
+          self.add_next_sibling sibling
+        end
+      end
+
+      def has_attribute?(property)
+        key? property
+      end
+
+      alias :get_attribute :[]
+      def set_attribute(name, value)
+        self[name] = value
+      end
+
+      def text
+        content
+      end
+      alias :inner_text :text
+
+      ####
+      # Set the content to +string+.
+      # If +encode+, encode any special characters first.
+      def content= string, encode = true
+        self.native_content = encode_special_chars(string)
+      end
+
+      ###
+      # Set the parent Node for this Node
+      def parent= parent_node
+        parent_node.add_child(self)
+        parent_node
+      end
+
+      def << child
+        add_child child
+      end
+
+      def comment?
+        type == COMMENT_NODE
+      end
+
+      def cdata?
+        type == CDATA_SECTION_NODE
+      end
+
+      def xml?
+        type == DOCUMENT_NODE
+      end
+
+      def html?
+        type == HTML_DOCUMENT_NODE
+      end
+
+      def text?
+        type == TEXT_NODE
+      end
+
+      def read_only?
+        # According to gdome2, these are read-only node types
+        [NOTATION_NODE, ENTITY_NODE, ENTITY_DECL].include?(type)
+      end
+
+      def element?
+        type == ELEMENT_NODE
+      end
+      alias :elem? :element?
+
+      def to_s
+        document.xml? ? to_xml : to_html
+      end
+
+      def inner_html
+        children.map { |x| x.to_html }.join
+      end
+
+      def css_path
+        path.split(/\//).map { |part|
+          part.length == 0 ? nil : part.gsub(/\[(\d+)\]/, ':nth-of-type(\1)')
+        }.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
+      def ancestors
+        parents = []
+
+        this_parent = self.parent
+
+        while this_parent != nil
+          parents << this_parent
+          this_parent = this_parent.parent
+        end
+        parents
+      end
+
+      ####
+      # Yields self and all children to +block+ recursively.
+      def traverse(&block)
+        children.each{|j| j.traverse(&block) }
+        block.call(self)
+      end
+
+      ####
+      #  replace node with the new node in the document.
+      def replace(new_node)
+        if new_node.is_a?(Document)
+          raise ArgumentError, <<-EOERR
+Node.replace requires a Node argument, and cannot accept a Document.
+(You probably want to select a node from the Document with at() or search(), or create a new Node via Node.new().)
+          EOERR
+        end
+        replace_with_node new_node
+      end
+
+      def == other
+        return false unless other
+        return false unless other.respond_to?(:pointer_id)
+        pointer_id == other.pointer_id
+      end
+    end
+  end
+end

data/lib/nokogiri/xml/node_set.rb

@@ -0,0 +1,197 @@
+module Nokogiri
+  module XML
+    class NodeSet
+      include Enumerable
+
+      attr_accessor :document
+
+      def initialize document, list = []
+        @document = document
+        list.each { |x| self << x }
+        yield self if block_given?
+      end
+
+      ###
+      # Get the first element of the NodeSet.
+      def first
+        self[0]
+      end
+
+      ###
+      # Get the last element of the NodeSet.
+      def last
+        self[length - 1]
+      end
+
+      ###
+      # Is this NodeSet empty?
+      def empty?
+        length == 0
+      end
+
+      ###
+      # Insert +datum+ before the first Node in this NodeSet
+      def before datum
+        first.before datum
+      end
+
+      ###
+      # Insert +datum+ after the last Node in this NodeSet
+      def after datum
+        last.after datum
+      end
+
+      ###
+      # Append +node+ to the NodeSet.
+      def << node
+        push(node)
+      end
+
+      ###
+      # Unlink this NodeSet and all Node objects it contains from their
+      # current context.
+      def unlink
+        each { |node| node.unlink }
+        self
+      end
+      alias :remove :unlink
+
+      ###
+      # Search this document for +paths+
+      def search *paths
+        sub_set = NodeSet.new(document)
+        document.decorate(sub_set)
+        each do |node|
+          node.search(*paths).each do |sub_node|
+            sub_set << sub_node
+          end
+        end
+        sub_set
+      end
+      alias :/ :search
+      alias :xpath :search
+      alias :css :search
+
+      ###
+      # If path is a string, search this document for +path+ returning the
+      # first Node.  Otherwise, index in to the array with +path+.
+      def at path, ns = {}
+        return self[path] if path.is_a?(Numeric)
+        search(path, ns).first
+      end
+
+      ###
+      # 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(" "))
+        end
+        self
+      end
+
+      ###
+      # Remove the class attribute +name+ from all Node objects 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(" "))
+          else
+            el.remove_attribute("class")
+          end
+        end
+        self
+      end
+
+      ###
+      # 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)
+        end
+      end
+      alias_method :set, :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
+        self      
+      end
+
+      ###
+      # Iterate over each node, yielding  to +block+
+      def each(&block)
+        x = 0
+        while x < length
+          yield self[x]
+          x += 1
+        end
+      end
+
+      ###
+      # Get the inner text of all contained Node objects
+      def inner_text
+        collect{|j| j.inner_text}.join('')
+      end
+      alias :text :inner_text
+
+      ###
+      # Get the inner html of all contained Node objects
+      def inner_html
+        collect{|j| j.inner_html}.join('')
+      end
+
+      ###
+      # 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)
+          j.replace(new_parent)
+          nest = new_parent
+          if nest.child
+            nest = nest.child until nest.child.nil?
+          end
+          j.parent = nest
+        end
+        self
+      end
+
+      def to_s
+        map { |x| x.to_s }.join
+      end
+
+      def to_html
+        map { |x| x.to_html }.join('')
+      end
+
+      def to_xml *args
+        map { |x| x.to_xml(*args) }.join('')
+      end
+
+      def size
+        length
+      end
+
+      def to_ary
+        to_a
+      end
+    end
+  end
+end