nokogiri 1.18.0.rc1-x86_64-linux-musl

data/lib/nokogiri/xml/document_fragment.rb

@@ -0,0 +1,276 @@
+# coding: utf-8
+# frozen_string_literal: true
+
+module Nokogiri
+  module XML
+    # DocumentFragment represents a fragment of an \XML document. It provides the same functionality
+    # exposed by XML::Node and can be used to contain one or more \XML subtrees.
+    class DocumentFragment < Nokogiri::XML::Node
+      # The options used to parse the document fragment. Returns the value of any options that were
+      # passed into the constructor as a parameter or set in a config block, else the default
+      # options for the specific subclass.
+      attr_reader :parse_options
+
+      class << self
+        # :call-seq:
+        #   parse(input) { |options| ... } → XML::DocumentFragment
+        #   parse(input, options:) → XML::DocumentFragment
+        #
+        # Parse \XML fragment input from a String, and return a new XML::DocumentFragment. This
+        # method creates a new, empty XML::Document to contain the fragment.
+        #
+        # [Required Parameters]
+        # - +input+ (String) The content to be parsed.
+        #
+        # [Optional Keyword Arguments]
+        # - +options+ (Nokogiri::XML::ParseOptions) Configuration object that determines some
+        #   behaviors during parsing. See ParseOptions for more information. The default value is
+        #   +ParseOptions::DEFAULT_XML+.
+        #
+        # [Yields]
+        #   If a block is given, a Nokogiri::XML::ParseOptions object is yielded to the block which
+        #   can be configured before parsing. See Nokogiri::XML::ParseOptions for more information.
+        #
+        # [Returns] Nokogiri::XML::DocumentFragment
+        def parse(tags, options_ = ParseOptions::DEFAULT_XML, options: options_, &block)
+          new(XML::Document.new, tags, options: options, &block)
+        end
+
+        # Wrapper method to separate the concerns of:
+        # - the native object allocator's parameter (it only requires `document`)
+        # - the initializer's parameters
+        def new(document, ...) # :nodoc:
+          instance = native_new(document)
+          instance.send(:initialize, document, ...)
+          instance
+        end
+      end
+
+      # :call-seq:
+      #   new(document, input=nil) { |options| ... } → DocumentFragment
+      #   new(document, input=nil, context:, options:) → DocumentFragment
+      #
+      # Parse \XML fragment input from a String, and return a new DocumentFragment that is
+      # associated with the given +document+.
+      #
+      # 💡 It's recommended to use either XML::DocumentFragment.parse or Node#parse rather than call
+      # this method directly.
+      #
+      # [Required Parameters]
+      # - +document+ (XML::Document) The parent document to associate the returned fragment with.
+      #
+      # [Optional Parameters]
+      # - +input+ (String) The content to be parsed.
+      #
+      # [Optional Keyword Arguments]
+      # - +context:+ (Nokogiri::XML::Node) The <b>context node</b> for the subtree created. See
+      #   below for more information.
+      #
+      # - +options:+ (Nokogiri::XML::ParseOptions) Configuration object that determines some
+      #   behaviors during parsing. See ParseOptions for more information. The default value is
+      #   +ParseOptions::DEFAULT_XML+.
+      #
+      # [Yields]
+      #   If a block is given, a Nokogiri::XML::ParseOptions object is yielded to the block which
+      #   can be configured before parsing. See ParseOptions for more information.
+      #
+      # [Returns] XML::DocumentFragment
+      #
+      # === Context \Node
+      #
+      # If a context node is specified using +context:+, then the fragment will be created by
+      # calling Node#parse on that node, so the parser will behave as if that Node is the parent of
+      # the fragment subtree, and will resolve namespaces relative to that node.
+      #
+      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
+
+      if Nokogiri.uses_libxml?
+        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
+      end
+
+      ###
+      # return the name for DocumentFragment
+      def name
+        "#document-fragment"
+      end
+
+      ###
+      # Convert this DocumentFragment to a string
+      def to_s
+        children.to_s
+      end
+
+      ###
+      # Convert this DocumentFragment to html
+      # See Nokogiri::XML::NodeSet#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
+
+      ###
+      # Convert this DocumentFragment to xhtml
+      # See Nokogiri::XML::NodeSet#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
+
+      ###
+      # Convert this DocumentFragment to xml
+      # See Nokogiri::XML::NodeSet#to_xml
+      def to_xml(*args)
+        children.to_xml(*args)
+      end
+
+      ###
+      # call-seq: css *rules, [namespace-bindings, custom-pseudo-class]
+      #
+      # Search this fragment for CSS +rules+. +rules+ must be one or more CSS
+      # selectors. For example:
+      #
+      # For more information see Nokogiri::XML::Searchable#css
+      def css(*args)
+        if children.any?
+          children.css(*args) # 'children' is a smell here
+        else
+          NodeSet.new(document)
+        end
+      end
+
+      #
+      #  NOTE that we don't delegate #xpath to children ... another smell.
+      #  def xpath ; end
+      #
+
+      ###
+      # call-seq: search *paths, [namespace-bindings, xpath-variable-bindings, custom-handler-class]
+      #
+      # Search this fragment for +paths+. +paths+ must be one or more XPath or CSS queries.
+      #
+      # For more information see Nokogiri::XML::Searchable#search
+      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
+
+      alias_method :serialize, :to_s
+
+      # A list of Nokogiri::XML::SyntaxError found when parsing a document
+      def errors
+        document.errors
+      end
+
+      def errors=(things) # :nodoc:
+        document.errors = things
+      end
+
+      def fragment(data)
+        document.fragment(data)
+      end
+
+      #
+      #  :call-seq: deconstruct() → Array
+      #
+      #  Returns the root nodes of this document fragment as an array, to use in pattern matching.
+      #
+      #  💡 Note that text nodes are returned as well as elements. If you wish to operate only on
+      #  root elements, you should deconstruct the array returned by
+      #  <tt>DocumentFragment#elements</tt>.
+      #
+      #  *Example*
+      #
+      #    frag = Nokogiri::HTML5.fragment(<<~HTML)
+      #      <div>Start</div>
+      #      This is a <a href="#jump">shortcut</a> for you.
+      #      <div>End</div>
+      #    HTML
+      #
+      #    frag.deconstruct
+      #    # => [#(Element:0x35c { name = "div", children = [ #(Text "Start")] }),
+      #    #     #(Text "\n" + "This is a "),
+      #    #     #(Element:0x370 {
+      #    #       name = "a",
+      #    #       attributes = [ #(Attr:0x384 { name = "href", value = "#jump" })],
+      #    #       children = [ #(Text "shortcut")]
+      #    #       }),
+      #    #     #(Text " for you.\n"),
+      #    #     #(Element:0x398 { name = "div", children = [ #(Text "End")] }),
+      #    #     #(Text "\n")]
+      #
+      #  *Example* only the elements, not the text nodes.
+      #
+      #    frag.elements.deconstruct
+      #    # => [#(Element:0x35c { name = "div", children = [ #(Text "Start")] }),
+      #    #     #(Element:0x370 {
+      #    #       name = "a",
+      #    #       attributes = [ #(Attr:0x384 { name = "href", value = "#jump" })],
+      #    #       children = [ #(Text "shortcut")]
+      #    #       }),
+      #    #     #(Element:0x398 { name = "div", children = [ #(Text "End")] })]
+      #
+      #  Since v1.14.0
+      #
+      def deconstruct
+        children.to_a
+      end
+
+      private
+
+      # 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
+    end
+  end
+end

data/lib/nokogiri/xml/dtd.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Nokogiri
+  module XML
+    class DTD < Nokogiri::XML::Node
+      undef_method :attribute_nodes
+      undef_method :values
+      undef_method :content
+      undef_method :namespace
+      undef_method :namespace_definitions
+      undef_method :line if method_defined?(:line)
+
+      def keys
+        attributes.keys
+      end
+
+      def each
+        attributes.each do |key, value|
+          yield([key, value])
+        end
+      end
+
+      def html_dtd?
+        name.casecmp("html").zero?
+      end
+
+      def html5_dtd?
+        html_dtd? &&
+          external_id.nil? &&
+          (system_id.nil? || system_id == "about:legacy-compat")
+      end
+    end
+  end
+end

data/lib/nokogiri/xml/element_content.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Nokogiri
+  module XML
+    ###
+    # Represents the allowed content in an Element Declaration inside a DTD:
+    #
+    #   <?xml version="1.0"?><?TEST-STYLE PIDATA?>
+    #   <!DOCTYPE staff SYSTEM "staff.dtd" [
+    #      <!ELEMENT div1 (head, (p | list | note)*, div2*)>
+    #   ]>
+    #   </root>
+    #
+    # ElementContent represents the binary tree inside the <!ELEMENT> tag shown above that lists the
+    # possible content for the div1 tag.
+    class ElementContent
+      include Nokogiri::XML::PP::Node
+
+      # Possible definitions of type
+      PCDATA  = 1
+      ELEMENT = 2
+      SEQ     = 3
+      OR      = 4
+
+      # Possible content occurrences
+      ONCE    = 1
+      OPT     = 2
+      MULT    = 3
+      PLUS    = 4
+
+      attr_reader :document
+
+      ###
+      # Get the children of this ElementContent node
+      def children
+        [c1, c2].compact
+      end
+
+      private
+
+      def inspect_attributes
+        [:prefix, :name, :type, :occur, :children]
+      end
+    end
+  end
+end

data/lib/nokogiri/xml/element_decl.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Nokogiri
+  module XML
+    class ElementDecl < Nokogiri::XML::Node
+      undef_method :namespace
+      undef_method :namespace_definitions
+      undef_method :line if method_defined?(:line)
+
+      private
+
+      def inspect_attributes
+        [:to_s]
+      end
+    end
+  end
+end

data/lib/nokogiri/xml/entity_decl.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Nokogiri
+  module XML
+    class EntityDecl < Nokogiri::XML::Node
+      undef_method :attribute_nodes
+      undef_method :attributes
+      undef_method :namespace
+      undef_method :namespace_definitions
+      undef_method :line if method_defined?(:line)
+
+      def self.new(name, doc, *args)
+        doc.create_entity(name, *args)
+      end
+
+      private
+
+      def inspect_attributes
+        [:to_s]
+      end
+    end
+  end
+end

data/lib/nokogiri/xml/entity_reference.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Nokogiri
+  module XML
+    class EntityReference < Nokogiri::XML::Node
+      def children
+        # libxml2 will create a malformed child node for predefined
+        # entities. because any use of that child is likely to cause a
+        # segfault, we shall pretend that it doesn't exist.
+        #
+        # see https://github.com/sparklemotion/nokogiri/issues/1238 for details
+        NodeSet.new(document)
+      end
+
+      def inspect_attributes
+        [:name]
+      end
+    end
+  end
+end

data/lib/nokogiri/xml/namespace.rb

@@ -0,0 +1,57 @@
+# coding: utf-8
+# frozen_string_literal: true
+
+module Nokogiri
+  module XML
+    class Namespace
+      include Nokogiri::XML::PP::Node
+      attr_reader :document
+
+      #
+      #  :call-seq: deconstruct_keys(array_of_names) → Hash
+      #
+      #  Returns a hash describing the Namespace, to use in pattern matching.
+      #
+      #  Valid keys and their values:
+      #  - +prefix+ → (String, nil) The namespace's prefix, or +nil+ if there is no prefix (e.g., default namespace).
+      #  - +href+ → (String) The namespace's URI
+      #
+      #  *Example*
+      #
+      #    doc = Nokogiri::XML.parse(<<~XML)
+      #      <?xml version="1.0"?>
+      #      <root xmlns="http://nokogiri.org/ns/default" xmlns:noko="http://nokogiri.org/ns/noko">
+      #        <child1 foo="abc" noko:bar="def"/>
+      #        <noko:child2 foo="qwe" noko:bar="rty"/>
+      #      </root>
+      #    XML
+      #
+      #    doc.root.elements.first.namespace
+      #    # => #(Namespace:0x35c { href = "http://nokogiri.org/ns/default" })
+      #
+      #    doc.root.elements.first.namespace.deconstruct_keys([:prefix, :href])
+      #    # => {:prefix=>nil, :href=>"http://nokogiri.org/ns/default"}
+      #
+      #    doc.root.elements.last.namespace
+      #    # => #(Namespace:0x370 {
+      #    #      prefix = "noko",
+      #    #      href = "http://nokogiri.org/ns/noko"
+      #    #      })
+      #
+      #    doc.root.elements.last.namespace.deconstruct_keys([:prefix, :href])
+      #    # => {:prefix=>"noko", :href=>"http://nokogiri.org/ns/noko"}
+      #
+      #  Since v1.14.0
+      #
+      def deconstruct_keys(keys)
+        { prefix: prefix, href: href }
+      end
+
+      private
+
+      def inspect_attributes
+        [:prefix, :href]
+      end
+    end
+  end
+end

data/lib/nokogiri/xml/node/save_options.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Nokogiri
+  module XML
+    class Node
+      ###
+      # Save options for serializing nodes.
+      # See the method group entitled Node@Serialization+and+Generating+Output for usage.
+      class SaveOptions
+        # Format serialized xml
+        FORMAT          = 1
+        # Do not include declarations
+        NO_DECLARATION  = 2
+        # Do not include empty tags
+        NO_EMPTY_TAGS   = 4
+        # Do not save XHTML
+        NO_XHTML        = 8
+        # Save as XHTML
+        AS_XHTML        = 16
+        # Save as XML
+        AS_XML          = 32
+        # Save as HTML
+        AS_HTML         = 64
+
+        if Nokogiri.jruby?
+          # Save builder created document
+          AS_BUILDER = 128
+          # the default for XML documents
+          DEFAULT_XML  = AS_XML # https://github.com/sparklemotion/nokogiri/issues/#issue/415
+          # the default for HTML document
+          DEFAULT_HTML = NO_DECLARATION | NO_EMPTY_TAGS | AS_HTML
+          # the default for XHTML document
+          DEFAULT_XHTML = NO_DECLARATION | AS_XHTML
+        else
+          # the default for XML documents
+          DEFAULT_XML  = FORMAT | AS_XML
+          # the default for HTML document
+          DEFAULT_HTML = FORMAT | NO_DECLARATION | NO_EMPTY_TAGS | AS_HTML
+          # the default for XHTML document
+          DEFAULT_XHTML = FORMAT | NO_DECLARATION | AS_XHTML
+        end
+
+        # Integer representation of the SaveOptions
+        attr_reader :options
+
+        # Create a new SaveOptions object with +options+
+        def initialize(options = 0)
+          @options = options
+        end
+
+        constants.each do |constant|
+          class_eval <<~RUBY, __FILE__, __LINE__ + 1
+            def #{constant.downcase}
+              @options |= #{constant}
+              self
+            end
+
+            def #{constant.downcase}?
+              #{constant} & @options == #{constant}
+            end
+          RUBY
+        end
+
+        alias_method :to_i, :options
+
+        def inspect
+          options = []
+          self.class.constants.each do |k|
+            options << k.downcase if send(:"#{k.downcase}?")
+          end
+          super.sub(/>$/, " " + options.join(", ") + ">")
+        end
+      end
+    end
+  end
+end