class Nokogiri::XML::DocumentFragment

def self.parse(tags, options = ParseOptions::DEFAULT_XML, &block)

Create a Nokogiri::XML::DocumentFragment from +tags+
### 
def self.parse(tags, options = ParseOptions::DEFAULT_XML, &block)
  new(XML::Document.new, tags, nil, options, &block)
end

def css(*args)

For more information see Nokogiri::XML::Searchable#css

selectors. For example:
Search this fragment for CSS +rules+. +rules+ must be one or more CSS

call-seq: css *rules, [namespace-bindings, custom-pseudo-class]
## 
def css(*args)
  if children.any?
    children.css(*args) # 'children' is a smell here
  else
    NodeSet.new(document)
  end
end

def deconstruct


Since v1.14.0

# #(Element:0x398 { name = "div", children = [ #(Text "End")] })]
# }),
# children = [ #(Text "shortcut")]
# attributes = [ #(Attr:0x384 { name = "href", value = "#jump" })],
# name = "a",
# #(Element:0x370 {
# => [#(Element:0x35c { name = "div", children = [ #(Text "Start")] }),
frag.elements.deconstruct

*Example* only the elements, not the text nodes.

# #(Text "\n")]
# #(Element:0x398 { name = "div", children = [ #(Text "End")] }),
# #(Text " for you.\n"),
# }),
# children = [ #(Text "shortcut")]
# attributes = [ #(Attr:0x384 { name = "href", value = "#jump" })],
# name = "a",
# #(Element:0x370 {
# #(Text "\n" + "This is a "),
# => [#(Element:0x35c { name = "div", children = [ #(Text "Start")] }),
frag.deconstruct

HTML
End

This is a shortcut for you.
Start

frag = Nokogiri::HTML5.fragment(<<~HTML)

*Example*

DocumentFragment#elements.
root elements, you should deconstruct the array returned by
💡 Note that text nodes are returned as well as elements. If you wish to operate only on

Returns the root nodes of this document fragment as an array, to use in pattern matching.

:call-seq: deconstruct() → Array
def deconstruct
  children.to_a
end

def dup 

def dup
  new_document = document.dup
  new_fragment = self.class.new(new_document)
  children.each do |child|
    child.dup(1, new_document).parent = new_fragment
  end
  new_fragment
end

def errors

A list of Nokogiri::XML::SyntaxError found when parsing a document 
def errors
  document.errors
end

def errors=(things) # :nodoc:

:nodoc: 
def errors=(things) # :nodoc:
  document.errors = things
end

def fragment(data) 

def fragment(data)
  document.fragment(data)
end

def initialize(document, tags = nil, ctx = nil, options = ParseOptions::DEFAULT_XML) # rubocop:disable Lint/MissingSuper

rubocop:disable Lint/MissingSuper
to +ctx+.
subtree created, e.g., namespaces will be resolved relative
If +ctx+ is present, it is used as a context node for the

Create a new DocumentFragment from +tags+.
# 
def initialize(document, tags = nil, ctx = nil, options = ParseOptions::DEFAULT_XML) # rubocop:disable Lint/MissingSuper
  return self unless tags
  options = Nokogiri::XML::ParseOptions.new(options) if Integer === options
  yield options if block_given?
  children = if ctx
    # Fix for issue#490
    if Nokogiri.jruby?
      # fix for issue #770
      ctx.parse("<root #{namespace_declarations(ctx)}>#{tags}</root>", options).children
    else
      ctx.parse(tags, options)
    end
  else
    wrapper_doc = XML::Document.parse("<root>#{tags}</root>", nil, nil, options)
    self.errors = wrapper_doc.errors
    wrapper_doc.xpath("/root/node()")
  end
  children.each { |child| child.parent = self }
end

def name

return the name for DocumentFragment
## 
def name
  "#document-fragment"
end

def namespace_declarations(ctx)

fix for issue 770 
def namespace_declarations(ctx)
  ctx.namespace_scopes.map do |namespace|
    prefix = namespace.prefix.nil? ? "" : ":#{namespace.prefix}"
    %{xmlns#{prefix}="#{namespace.href}"}
  end.join(" ")
end

def search(*rules)

For more information see Nokogiri::XML::Searchable#search

Search this fragment for +paths+. +paths+ must be one or more XPath or CSS queries.

call-seq: search *paths, [namespace-bindings, xpath-variable-bindings, custom-handler-class]
## 
def search(*rules)
  rules, handler, ns, binds = extract_params(rules)
  rules.inject(NodeSet.new(document)) do |set, rule|
    set + if Searchable::LOOKS_LIKE_XPATH.match?(rule)
      xpath(*[rule, ns, handler, binds].compact)
    else
      children.css(*[rule, ns, handler].compact) # 'children' is a smell here
    end
  end
end

def to_html(*args)

See Nokogiri::XML::NodeSet#to_html
Convert this DocumentFragment to html
## 
def to_html(*args)
  if Nokogiri.jruby?
    options = args.first.is_a?(Hash) ? args.shift : {}
    options[:save_with] ||= Node::SaveOptions::DEFAULT_HTML
    args.insert(0, options)
  end
  children.to_html(*args)
end

def to_s

Convert this DocumentFragment to a string
## 
def to_s
  children.to_s
end

def to_xhtml(*args)

See Nokogiri::XML::NodeSet#to_xhtml
Convert this DocumentFragment to xhtml
## 
def to_xhtml(*args)
  if Nokogiri.jruby?
    options = args.first.is_a?(Hash) ? args.shift : {}
    options[:save_with] ||= Node::SaveOptions::DEFAULT_XHTML
    args.insert(0, options)
  end
  children.to_xhtml(*args)
end

def to_xml(*args)

See Nokogiri::XML::NodeSet#to_xml
Convert this DocumentFragment to xml
## 
def to_xml(*args)
  children.to_xml(*args)
end