class Nokogiri::XML::Document

Nokogiri::XML::Node#xpath
For searching a Document, see Nokogiri::XML::Node#css and
See Nokogiri.XML()
XML documents. The Document is created by parsing an XML document.
Nokogiri::XML::Document is the main entry point for dealing with
#

def self.parse string_or_io, url = nil, encoding = nil, options = ParseOptions::DEFAULT_XML, &block

Nokogiri::XML::ParseOptions.
Nokogiri::XML::ParseOptions::RECOVER. See the constants in
is a number that sets options in the parser, such as
encoding that should be used when processing the document. +options+
+url+ is resource where this document is located. +encoding+ is the
responds to _read_ and _close_ such as an IO, or StringIO.
Parse an XML file. +thing+ may be a String, or any object that
# 
def self.parse string_or_io, url = nil, encoding = nil, options = ParseOptions::DEFAULT_XML, &block
  options = Nokogiri::XML::ParseOptions.new(options) if Fixnum === options
  # Give the options to the user
  yield options if block_given?
  if string_or_io.respond_to?(:read)
    url ||= string_or_io.respond_to?(:path) ? string_or_io.path : nil
    return read_io(string_or_io, url, encoding, options.to_i)
  end
  # read_memory pukes on empty docs
  return new if string_or_io.nil? or string_or_io.empty?
  read_memory(string_or_io, url, encoding, options.to_i)
end

def add_child child 

def add_child child
  raise "Document already has a root node" if root
  if child.type == Node::DOCUMENT_FRAG_NODE
    raise "Document cannot have multiple root nodes" if child.children.size > 1
    super(child.children.first)
  else
    super
  end
end

def collect_namespaces

libxml bridge into a ruby object.
traverses the entire graph, and also has to bring each node accross the
Note this is a very expensive operation in current implementation, as it

in the hash.
Non-prefixed default namespaces (as in "xmlns=") are not included

The hash returned will look like this: { 'xmlns:foo' => 'bar' }





For example, given this document:
WARNING: this method will clobber duplicate names in the keys.

{ 'xmlns:foo' => 'bar', 'xmlns:hello' => 'world' }

This method will return:





For example, given this document:

return them as a hash.
Recursively get all namespaces from this node and its subtree and
# 
def collect_namespaces
  ns = {}
  traverse { |j| ns.merge!(j.namespaces) }
  ns
end

def create_cdata text

Create a CDATA element containing +text+ 
def create_cdata text
  Nokogiri::XML::CDATA.new(self, text.to_s)
end

def create_element name, *args, &block


doc.create_element "div" { |node| node['class'] = "container" } #

doc.create_element "div", "contents", :class => "container" #
contents

doc.create_element "div", "contents" #
contents

doc.create_element "div", :class => "container" #

doc.create_element "div" #


Create an element with +name+, and optionally setting the content and attributes.
# 
def create_element name, *args, &block
  elm = Nokogiri::XML::Element.new(name, self, &block)
  args.each do |arg|
    case arg
    when Hash
      arg.each { |k,v|
        key = k.to_s
        if key =~ /^xmlns(:\w+)?$/
          ns_name = key.split(":", 2)[1]
          elm.add_namespace_definition ns_name, v
          next
        end
        elm[k.to_s] = v.to_s
      }
    else
      elm.content = arg
    end
  end
  elm
end

def create_text_node text, &block

Create a text node with +text+ 
def create_text_node text, &block
  Nokogiri::XML::Text.new(text.to_s, self, &block)
end

def decorate node

Apply any decorators to +node+
# 
def decorate node
  return unless @decorators
  @decorators.each { |klass,list|
    next unless node.is_a?(klass)
    list.each { |moodule| node.extend(moodule) }
  }
end

def decorators key

Get the list of decorators given +key+ 
def decorators key
  @decorators ||= Hash.new
  @decorators[key] ||= []
end

def document

A reference to +self+ 
def document
  self
end

def fragment tags = nil

Returns an empty fragment if +tags+ is nil.
Create a Nokogiri::XML::DocumentFragment from +tags+
# 
def fragment tags = nil
  DocumentFragment.new(self, tags, self.root)
end

def implied_xpath_context 

def implied_xpath_context
  "/"
end

def initialize *args # :nodoc:

:nodoc: 
def initialize *args # :nodoc:
  @errors     = []
  @decorators = nil
end

def inspect_attributes 

def inspect_attributes
  [:name, :children]
end

def name

The name of this document. Always returns "document" 
def name
  'document'
end

def namespaces

Get the hash of namespaces on the root Nokogiri::XML::Node 
def namespaces
  root ? root.namespaces : {}
end

def slop!


... which does absolutely nothing.
irb> doc.slop!
... followed by irb's implicit inspect (and therefore instantiation of every node) ...
irb> doc = Nokogiri::HTML my_markup

and not

irb> doc = Nokogiri::Slop my_markup

irb, the preferred idiom is:
is called will not be decorated with sloppy behavior. So, if you're in
Note that any nodes that have been instantiated before #slop!

Explore a document with shortcut methods. See Nokogiri::Slop for details.
# 
def slop!
  unless decorators(XML::Node).include? Nokogiri::Decorators::Slop
    decorators(XML::Node) << Nokogiri::Decorators::Slop
    decorate!
  end
  self
end

def validate

the document or +nil+ when there is no DTD.
Validate this Document against it's DTD. Returns a list of errors on
# 
def validate
  return nil unless internal_subset
  internal_subset.validate self
end