class Nokogiri::XML::Document

def add_child(node_or_tags)
  raise "A document may not have multiple root nodes." if (root && root.name != "nokogiri_text_wrapper") && !(node_or_tags.comment? || node_or_tags.processing_instruction?)
  node_or_tags = coerce(node_or_tags)
  if node_or_tags.is_a?(XML::NodeSet)
    raise "A document may not have multiple root nodes." if node_or_tags.size > 1
    super(node_or_tags.first)
  else
    super
  end
end

def clone(level = 1)
  copy = OBJECT_CLONE_METHOD.bind_call(self)
  copy.initialize_copy_with_args(self, level)
end

def collect_namespaces
  xpath("//namespace::*").each_with_object({}) do |ns, hash|
    hash[["xmlns", ns.prefix].compact.join(":")] = ns.href if ns.prefix != "xml"
  end
end

def create_cdata(string, &block)
  Nokogiri::XML::CDATA.new(self, string.to_s, &block)
end

def create_comment(string, &block)
  Nokogiri::XML::Comment.new(self, string.to_s, &block)
end

def create_element(name, *contents_or_attrs, &block)
  elm = Nokogiri::XML::Element.new(name, self, &block)
  contents_or_attrs.each do |arg|
    case arg
    when Hash
      arg.each do |k, v|
        key = k.to_s
        if key =~ NCNAME_RE
          ns_name = Regexp.last_match(1)
          elm.add_namespace_definition(ns_name, v)
        else
          elm[k.to_s] = v.to_s
        end
      end
    else
      elm.content = arg
    end
  end
  if (ns = elm.namespace_definitions.find { |n| n.prefix.nil? || (n.prefix == "") })
    elm.namespace = ns
  end
  elm
end

def create_text_node(string, &block)
  Nokogiri::XML::Text.new(string.to_s, self, &block)
end

def deconstruct_keys(keys)
  { root: root }
end

def decorate(node)
  return unless @decorators
  @decorators.each do |klass, list|
    next unless node.is_a?(klass)
    list.each { |mod| node.extend(mod) }
  end
end

def decorators(key)
  @decorators ||= {}
  @decorators[key] ||= []
end

def document
  self
end

def dup(level = 1)
  copy = OBJECT_DUP_METHOD.bind_call(self)
  copy.initialize_copy_with_args(self, level)
end

def empty_doc?(string_or_io)
  string_or_io.nil? ||
    (string_or_io.respond_to?(:empty?) && string_or_io.empty?) ||
    (string_or_io.respond_to?(:eof?) && string_or_io.eof?)
end

def fragment(tags = nil)
  DocumentFragment.new(self, tags, root)
end

def initialize(*args) # :nodoc: # rubocop:disable Lint/MissingSuper
  @errors     = []
  @decorators = nil
  @namespace_inheritance = false
end

def inspect_attributes
  [:name, :children]
end

def name
  "document"
end

def namespaces
  root ? root.namespaces : {}
end

def parse(
  string_or_io,
  url_ = nil, encoding_ = nil, options_ = XML::ParseOptions::DEFAULT_XML,
  url: url_, encoding: encoding_, options: options_
)
  options = Nokogiri::XML::ParseOptions.new(options) if Integer === options
  yield options if block_given?
  url ||= string_or_io.respond_to?(:path) ? string_or_io.path : nil
  if empty_doc?(string_or_io)
    if options.strict?
      raise Nokogiri::XML::SyntaxError, "Empty document"
    else
      return encoding ? new.tap { |i| i.encoding = encoding } : new
    end
  end
  doc = if string_or_io.respond_to?(:read)
    # TODO: should we instead check for respond_to?(:to_path) ?
    if string_or_io.is_a?(Pathname)
      # resolve the Pathname to the file and open it as an IO object, see #2110
      string_or_io = string_or_io.expand_path.open
      url ||= string_or_io.path
    end
    read_io(string_or_io, url, encoding, options.to_i)
  else
    # read_memory pukes on empty docs
    read_memory(string_or_io, url, encoding, options.to_i)
  end
  # do xinclude processing
  doc.do_xinclude(options) if options.xinclude?
  doc
end

def slop!
  unless decorators(XML::Node).include?(Nokogiri::Decorators::Slop)
    decorators(XML::Node) << Nokogiri::Decorators::Slop
    decorate!
  end
  self
end

def validate
  return unless internal_subset
  internal_subset.validate(self)
end

def xpath_doctype
  Nokogiri::CSS::XPathVisitor::DoctypeConfig::XML
end