class Nokogiri::HTML4::Document

Experimental RBS support (using type sampling data from the type_fusion project). 

# sig/nokogiri/html4/document.rbs

class Nokogiri::HTML4::Document < Nokogiri::HTML4::Nokogiri::XML::Document
  def parse: (String string_or_io, ?nil url, ?String encoding, ?Nokogiri::XML::ParseOptions options) -> Nokogiri::HTML4::Document
end

def fragment(tags = nil)

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

def meta_content_type 

def meta_content_type
  xpath("//meta[@http-equiv and boolean(@content)]").find do |node|
    node["http-equiv"] =~ /\AContent-Type\z/i
  end
end

def meta_encoding

then nil is returned.
Get the meta tag encoding for this document. If there is no meta tag,
## 
def meta_encoding
  if (meta = at_xpath("//meta[@charset]"))
    meta[:charset]
  elsif (meta = meta_content_type)
    meta["content"][/charset\s*=\s*([\w-]+)/i, 1]
  end
end

def meta_encoding=(encoding)

into a head element.
Beware in CRuby, that libxml2 automatically inserts a meta tag

from the document encoding is undefined.
The result when trying to set an encoding that is different

content element (typically ) if any.
is inside a head element if any, and before any text node or
place supplying head and/or html elements as necessary, which
Otherwise, this method tries to create one at an appropriate

replaced with the given text.
If an meta encoding tag is already present, its content is

Set the meta tag encoding for this document.
## 
def meta_encoding=(encoding)
  if (meta = meta_content_type)
    meta["content"] = format("text/html; charset=%s", encoding)
    encoding
  elsif (meta = at_xpath("//meta[@charset]"))
    meta["charset"] = encoding
  else
    meta = XML::Node.new("meta", self)
    if (dtd = internal_subset) && dtd.html5_dtd?
      meta["charset"] = encoding
    else
      meta["http-equiv"] = "Content-Type"
      meta["content"] = format("text/html; charset=%s", encoding)
    end
    if (head = at_xpath("//head"))
      head.prepend_child(meta)
    else
      set_metadata_element(meta)
    end
    encoding
  end
end

def parse(string_or_io, url = nil, encoding = nil, options = XML::ParseOptions::DEFAULT_HTML)

Experimental RBS support (using type sampling data from the type_fusion project). 

def parse: (String string_or_io, ?nil url, ?String encoding, ?Nokogiri::XML::ParseOptions options) -> Nokogiri::HTML4::Document

This signature was generated using 9 samples from 1 application.

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 HTML. +string_or_io+ may be a String, or any object that
## 
def parse(string_or_io, url = nil, encoding = nil, options = XML::ParseOptions::DEFAULT_HTML)
  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 string_or_io.respond_to?(:encoding)
    unless string_or_io.encoding == Encoding::ASCII_8BIT
      encoding ||= string_or_io.encoding.name
    end
  end
  if string_or_io.respond_to?(:read)
    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
    unless encoding
      string_or_io = EncodingReader.new(string_or_io)
      begin
        return read_io(string_or_io, url, encoding, options.to_i)
      rescue EncodingReader::EncodingFound => e
        encoding = e.found_encoding
      end
    end
    return read_io(string_or_io, url, encoding, options.to_i)
  end
  # read_memory pukes on empty docs
  if string_or_io.nil? || string_or_io.empty?
    return encoding ? new.tap { |i| i.encoding = encoding } : new
  end
  encoding ||= EncodingReader.detect_encoding(string_or_io)
  read_memory(string_or_io, url, encoding, options.to_i)
end

def serialize(options = {})


end
config.format.as_xml
node.serialize(:encoding => 'UTF-8') do |config|

or

node.serialize(:encoding => 'UTF-8', :save_with => FORMAT | AS_XML)

These two statements are equivalent:

See also Nokogiri::XML::Node::SaveOptions and Node@Serialization+and+Generating+Output.

Serialize Node using +options+. Save options can also be set using a block.
### 
def serialize(options = {})
  options[:save_with] ||= XML::Node::SaveOptions::DEFAULT_HTML
  super
end

def set_metadata_element(element) # rubocop:disable Naming/AccessorMethodName

rubocop:disable Naming/AccessorMethodName 
def set_metadata_element(element) # rubocop:disable Naming/AccessorMethodName
  if (head = at_xpath("//head"))
    head << element
  elsif (html = at_xpath("//html"))
    head = html.prepend_child(XML::Node.new("head", self))
    head.prepend_child(element)
  elsif (first = children.find do |node|
           case node
           when XML::Element, XML::Text
             true
           end
         end)
    # We reach here only if the underlying document model
    # allows <html>/<head> elements to be omitted and does not
    # automatically supply them.
    first.add_previous_sibling(element)
  else
    html = add_child(XML::Node.new("html", self))
    head = html.add_child(XML::Node.new("head", self))
    head.prepend_child(element)
  end
end

def title

no title tag.
Get the title string of this document. Return nil if there is
## 
def title
  (title = at_xpath("//title")) && title.inner_text
end

def title=(text)

content element (typically ) if any.
encoding/charset tag if any, and before any text node or
is inside a head element if any, right after a meta
place supplying head and/or html elements as necessary, which
Otherwise, this method tries to create one at an appropriate

with the given text.
If a title element is already present, its content is replaced

Set the title string of this document.
## 
def title=(text)
  tnode = XML::Text.new(text, self)
  if (title = at_xpath("//title"))
    title.children = tnode
    return text
  end
  title = XML::Node.new("title", self) << tnode
  if (head = at_xpath("//head"))
    head << title
  elsif (meta = (at_xpath("//meta[@charset]") || meta_content_type))
    # better put after charset declaration
    meta.add_next_sibling(title)
  else
    set_metadata_element(title)
  end
end

def xpath_doctype

See XPathVisitor for more information.

[Returns] The document type which determines CSS-to-XPath translation.

xpath_doctype() → Nokogiri::CSS::XPathVisitor::DoctypeConfig
:call-seq: 
def xpath_doctype
  Nokogiri::CSS::XPathVisitor::DoctypeConfig::HTML4
end