class Nokogiri::XML::DocumentFragment

exposed by XML::Node and can be used to contain one or more XML subtrees.
DocumentFragment represents a fragment of an XML document. It provides the same functionality

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(


the fragment subtree, and will resolve namespaces relative to that node.
calling Node#parse on that node, so the parser will behave as if that Node is the parent of
If a context node is specified using +context:+, then the fragment will be created by

=== Context \Node

[Returns] XML::DocumentFragment

can be configured before parsing. See ParseOptions for more information.
If a block is given, a Nokogiri::XML::ParseOptions object is yielded to the block which
[Yields]

+ParseOptions::DEFAULT_XML+.
behaviors during parsing. See ParseOptions for more information. The default value is
- +options:+ (Nokogiri::XML::ParseOptions) Configuration object that determines some

below for more information.
- +context:+ (Nokogiri::XML::Node) The context node for the subtree created. See
[Optional Keyword Arguments]

- +input+ (String) The content to be parsed.
[Optional Parameters]

- +document+ (XML::Document) The parent document to associate the returned fragment with.
[Required Parameters]

this method directly.
💡 It's recommended to use either XML::DocumentFragment.parse or Node#parse rather than call

associated with the given +document+.
Parse \XML fragment input from a String, and return a new DocumentFragment that is

new(document, input=nil, context:, options:) → DocumentFragment
new(document, input=nil) { |options| ... } → DocumentFragment
:call-seq: 
def initialize(
  document, tags = nil,
  context_ = nil, options_ = ParseOptions::DEFAULT_XML,
  context: context_, options: options_
) # rubocop:disable Lint/MissingSuper
  return self unless tags
  options = Nokogiri::XML::ParseOptions.new(options) if Integer === options
  @parse_options = options
  yield options if block_given?
  children = if context
    # Fix for issue#490
    if Nokogiri.jruby?
      # fix for issue #770
      context.parse("<root #{namespace_declarations(context)}>#{tags}</root>", options).children
    else
      context.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 new(document, ...) # :nodoc:

:nodoc:
- the initializer's parameters
- the native object allocator's parameter (it only requires `document`)
Wrapper method to separate the concerns of: 
def new(document, ...) # :nodoc:
  instance = native_new(document)
  instance.send(:initialize, document, ...)
  instance
end

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

[Returns] Nokogiri::XML::DocumentFragment

can be configured before parsing. See Nokogiri::XML::ParseOptions for more information.
If a block is given, a Nokogiri::XML::ParseOptions object is yielded to the block which
[Yields]

+ParseOptions::DEFAULT_XML+.
behaviors during parsing. See ParseOptions for more information. The default value is
- +options+ (Nokogiri::XML::ParseOptions) Configuration object that determines some
[Optional Keyword Arguments]

- +input+ (String) The content to be parsed.
[Required Parameters]

method creates a new, empty XML::Document to contain the fragment.
Parse \XML fragment input from a String, and return a new XML::DocumentFragment. This

parse(input, options:) → XML::DocumentFragment
parse(input) { |options| ... } → XML::DocumentFragment
:call-seq: 
def parse(tags, options_ = ParseOptions::DEFAULT_XML, options: options_, &block)
  new(XML::Document.new, tags, options: options, &block)
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