nokogiri 1.13.0-aarch64-linux

data/lib/nokogiri/xml/node_set.rb

@@ -0,0 +1,364 @@
+# frozen_string_literal: true
+
+module Nokogiri
+  module XML
+    ####
+    # A NodeSet contains a list of Nokogiri::XML::Node objects.  Typically
+    # a NodeSet is return as a result of searching a Document via
+    # Nokogiri::XML::Searchable#css or Nokogiri::XML::Searchable#xpath
+    class NodeSet
+      include Nokogiri::XML::Searchable
+      include Enumerable
+
+      # The Document this NodeSet is associated with
+      attr_accessor :document
+
+      alias_method :clone, :dup
+
+      # Create a NodeSet with +document+ defaulting to +list+
+      def initialize(document, list = [])
+        @document = document
+        document.decorate(self)
+        list.each { |x| self << x }
+        yield self if block_given?
+      end
+
+      ###
+      # Get the first element of the NodeSet.
+      def first(n = nil)
+        return self[0] unless n
+        list = []
+        [n, length].min.times { |i| list << self[i] }
+        list
+      end
+
+      ###
+      # Get the last element of the NodeSet.
+      def last
+        self[-1]
+      end
+
+      ###
+      # Is this NodeSet empty?
+      def empty?
+        length == 0
+      end
+
+      ###
+      # Returns the index of the first node in self that is == to +node+ or meets the given block. Returns nil if no match is found.
+      def index(node = nil)
+        if node
+          warn("given block not used") if block_given?
+          each_with_index { |member, j| return j if member == node }
+        elsif block_given?
+          each_with_index { |member, j| return j if yield(member) }
+        end
+        nil
+      end
+
+      ###
+      # Insert +datum+ before the first Node in this NodeSet
+      def before(datum)
+        first.before(datum)
+      end
+
+      ###
+      # Insert +datum+ after the last Node in this NodeSet
+      def after(datum)
+        last.after(datum)
+      end
+
+      alias_method :<<, :push
+      alias_method :remove, :unlink
+
+      ###
+      # call-seq: css *rules, [namespace-bindings, custom-pseudo-class]
+      #
+      # Search this node set for CSS +rules+. +rules+ must be one or more CSS
+      # selectors. For example:
+      #
+      # For more information see Nokogiri::XML::Searchable#css
+      def css(*args)
+        rules, handler, ns, _ = extract_params(args)
+        paths = css_rules_to_xpath(rules, ns)
+
+        inject(NodeSet.new(document)) do |set, node|
+          set + xpath_internal(node, paths, handler, ns, nil)
+        end
+      end
+
+      ###
+      # call-seq: xpath *paths, [namespace-bindings, variable-bindings, custom-handler-class]
+      #
+      # Search this node set for XPath +paths+. +paths+ must be one or more XPath
+      # queries.
+      #
+      # For more information see Nokogiri::XML::Searchable#xpath
+      def xpath(*args)
+        paths, handler, ns, binds = extract_params(args)
+
+        inject(NodeSet.new(document)) do |set, node|
+          set + xpath_internal(node, paths, handler, ns, binds)
+        end
+      end
+
+      ###
+      # call-seq: search *paths, [namespace-bindings, xpath-variable-bindings, custom-handler-class]
+      #
+      # Search this object for +paths+, and return only the first
+      # result. +paths+ must be one or more XPath or CSS queries.
+      #
+      # See Searchable#search for more information.
+      #
+      # Or, if passed an integer, index into the NodeSet:
+      #
+      #   node_set.at(3) # same as node_set[3]
+      #
+      def at(*args)
+        if args.length == 1 && args.first.is_a?(Numeric)
+          return self[args.first]
+        end
+
+        super(*args)
+      end
+      alias_method :%, :at
+
+      ###
+      # Filter this list for nodes that match +expr+
+      def filter(expr)
+        find_all { |node| node.matches?(expr) }
+      end
+
+      ###
+      # Add the class attribute +name+ to all Node objects in the
+      # NodeSet.
+      #
+      # See Nokogiri::XML::Node#add_class for more information.
+      def add_class(name)
+        each do |el|
+          el.add_class(name)
+        end
+        self
+      end
+
+      ###
+      # Append the class attribute +name+ to all Node objects in the
+      # NodeSet.
+      #
+      # See Nokogiri::XML::Node#append_class for more information.
+      def append_class(name)
+        each do |el|
+          el.append_class(name)
+        end
+        self
+      end
+
+      ###
+      # Remove the class attribute +name+ from all Node objects in the
+      # NodeSet.
+      #
+      # See Nokogiri::XML::Node#remove_class for more information.
+      def remove_class(name = nil)
+        each do |el|
+          el.remove_class(name)
+        end
+        self
+      end
+
+      ###
+      # Set attributes on each Node in the NodeSet, or get an
+      # attribute from the first Node in the NodeSet.
+      #
+      # To get an attribute from the first Node in a NodeSet:
+      #
+      #   node_set.attr("href") # => "https://www.nokogiri.org"
+      #
+      # Note that an empty NodeSet will return nil when +#attr+ is called as a getter.
+      #
+      # To set an attribute on each node, +key+ can either be an
+      # attribute name, or a Hash of attribute names and values. When
+      # called as a setter, +#attr+ returns the NodeSet.
+      #
+      # If +key+ is an attribute name, then either +value+ or +block+
+      # must be passed.
+      #
+      # If +key+ is a Hash then attributes will be set for each
+      # key/value pair:
+      #
+      #   node_set.attr("href" => "https://www.nokogiri.org", "class" => "member")
+      #
+      # If +value+ is passed, it will be used as the attribute value
+      # for all nodes:
+      #
+      #   node_set.attr("href", "https://www.nokogiri.org")
+      #
+      # If +block+ is passed, it will be called on each Node object in
+      # the NodeSet and the return value used as the attribute value
+      # for that node:
+      #
+      #   node_set.attr("class") { |node| node.name }
+      #
+      def attr(key, value = nil, &block)
+        unless key.is_a?(Hash) || (key && (value || block))
+          return first ? first.attribute(key) : nil
+        end
+
+        hash = key.is_a?(Hash) ? key : { key => value }
+
+        hash.each do |k, v|
+          each do |node|
+            node[k] = v || yield(node)
+          end
+        end
+
+        self
+      end
+      alias_method :set, :attr
+      alias_method :attribute, :attr
+
+      ###
+      # Remove the attributed named +name+ from all Node objects in the NodeSet
+      def remove_attr(name)
+        each { |el| el.delete(name) }
+        self
+      end
+      alias_method :remove_attribute, :remove_attr
+
+      ###
+      # Iterate over each node, yielding  to +block+
+      def each
+        return to_enum unless block_given?
+
+        0.upto(length - 1) do |x|
+          yield self[x]
+        end
+        self
+      end
+
+      ###
+      # Get the inner text of all contained Node objects
+      #
+      # Note: This joins the text of all Node objects in the NodeSet:
+      #
+      #    doc = Nokogiri::XML('<xml><a><d>foo</d><d>bar</d></a></xml>')
+      #    doc.css('d').text # => "foobar"
+      #
+      # Instead, if you want to return the text of all nodes in the NodeSet:
+      #
+      #    doc.css('d').map(&:text) # => ["foo", "bar"]
+      #
+      # See Nokogiri::XML::Node#content for more information.
+      def inner_text
+        collect(&:inner_text).join("")
+      end
+      alias_method :text, :inner_text
+
+      ###
+      # Get the inner html of all contained Node objects
+      def inner_html(*args)
+        collect { |j| j.inner_html(*args) }.join("")
+      end
+
+      ###
+      # Wrap this NodeSet with +html+
+      def wrap(html)
+        map { |node| node.wrap(html) }
+      end
+
+      ###
+      # Convert this NodeSet to a string.
+      def to_s
+        map(&:to_s).join
+      end
+
+      ###
+      # Convert this NodeSet to HTML
+      def to_html(*args)
+        if Nokogiri.jruby?
+          options = args.first.is_a?(Hash) ? args.shift : {}
+          unless options[:save_with]
+            options[:save_with] = Node::SaveOptions::NO_DECLARATION | Node::SaveOptions::NO_EMPTY_TAGS | Node::SaveOptions::AS_HTML
+          end
+          args.insert(0, options)
+        end
+        map { |x| x.to_html(*args) }.join
+      end
+
+      ###
+      # Convert this NodeSet to XHTML
+      def to_xhtml(*args)
+        map { |x| x.to_xhtml(*args) }.join
+      end
+
+      ###
+      # Convert this NodeSet to XML
+      def to_xml(*args)
+        map { |x| x.to_xml(*args) }.join
+      end
+
+      alias_method :size, :length
+      alias_method :to_ary, :to_a
+
+      ###
+      # Removes the last element from set and returns it, or +nil+ if
+      # the set is empty
+      def pop
+        return nil if length == 0
+        delete(last)
+      end
+
+      ###
+      # Returns the first element of the NodeSet and removes it.  Returns
+      # +nil+ if the set is empty.
+      def shift
+        return nil if length == 0
+        delete(first)
+      end
+
+      ###
+      # Equality -- Two NodeSets are equal if the contain the same number
+      # of elements and if each element is equal to the corresponding
+      # element in the other NodeSet
+      def ==(other)
+        return false unless other.is_a?(Nokogiri::XML::NodeSet)
+        return false unless length == other.length
+        each_with_index do |node, i|
+          return false unless node == other[i]
+        end
+        true
+      end
+
+      ###
+      # Returns a new NodeSet containing all the children of all the nodes in
+      # the NodeSet
+      def children
+        node_set = NodeSet.new(document)
+        each do |node|
+          node.children.each { |n| node_set.push(n) }
+        end
+        node_set
+      end
+
+      ###
+      # Returns a new NodeSet containing all the nodes in the NodeSet
+      # in reverse order
+      def reverse
+        node_set = NodeSet.new(document)
+        (length - 1).downto(0) do |x|
+          node_set.push(self[x])
+        end
+        node_set
+      end
+
+      ###
+      # Return a nicely formated string representation
+      def inspect
+        "[#{map(&:inspect).join(", ")}]"
+      end
+
+      alias_method :+, :|
+
+      IMPLIED_XPATH_CONTEXTS = [".//", "self::"].freeze # :nodoc:
+    end
+  end
+end

data/lib/nokogiri/xml/notation.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Nokogiri
+  module XML
+    # Struct representing an {XML Schema Notation}[https://www.w3.org/TR/xml/#Notations]
+    class Notation < Struct.new(:name, :public_id, :system_id)
+      # dead comment to ensure rdoc processing
+
+      # :attr: name (String)
+      # The name for the element.
+
+      # :attr: public_id (String)
+      # The URI corresponding to the public identifier
+
+      # :attr: system_id (String,nil)
+      # The URI corresponding to the system identifier
+    end
+  end
+end

data/lib/nokogiri/xml/parse_options.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+module Nokogiri
+  module XML
+    ###
+    # Parse options for passing to Nokogiri.XML or Nokogiri.HTML
+    #
+    # == Building combinations of parse options
+    # You can build your own combinations of these parse options by using any of the following methods:
+    # *Note*: All examples attempt to set the +RECOVER+ & +NOENT+ options.
+    # [Ruby's bitwise operators] You can use the Ruby bitwise operators to set various combinations.
+    #   Nokogiri.XML('<content>Chapter 1</content', nil, nil, Nokogiri::XML::ParseOptions.new((1 << 0) | (1 << 1)))
+    # [Method chaining] Every option has an equivalent method in lowercase. You can chain these methods together to set various combinations.
+    #   Nokogiri.XML('<content>Chapter 1</content', nil, nil, Nokogiri::XML::ParseOptions.new.recover.noent)
+    # [Using Ruby Blocks] You can also setup parse combinations in the block passed to Nokogiri.XML or Nokogiri.HTML
+    #   Nokogiri.XML('<content>Chapter 1</content') {|config| config.recover.noent}
+    #
+    # == Removing particular parse options
+    # You can also remove options from an instance of +ParseOptions+ dynamically.
+    # Every option has an equivalent <code>no{option}</code> method in lowercase. You can call these methods on an instance of +ParseOptions+ to remove the option.
+    # Note that this is not available for +STRICT+.
+    #
+    #   # Setting the RECOVER & NOENT options...
+    #   options = Nokogiri::XML::ParseOptions.new.recover.noent
+    #   # later...
+    #   options.norecover # Removes the Nokogiri::XML::ParseOptions::RECOVER option
+    #   options.nonoent # Removes the Nokogiri::XML::ParseOptions::NOENT option
+    #
+    class ParseOptions
+      # Strict parsing
+      STRICT      = 0
+      # Recover from errors
+      RECOVER     = 1 << 0
+      # Substitute entities
+      NOENT       = 1 << 1
+      # Load external subsets
+      DTDLOAD     = 1 << 2
+      # Default DTD attributes
+      DTDATTR     = 1 << 3
+      # validate with the DTD
+      DTDVALID    = 1 << 4
+      # suppress error reports
+      NOERROR     = 1 << 5
+      # suppress warning reports
+      NOWARNING   = 1 << 6
+      # pedantic error reporting
+      PEDANTIC    = 1 << 7
+      # remove blank nodes
+      NOBLANKS    = 1 << 8
+      # use the SAX1 interface internally
+      SAX1        = 1 << 9
+      # Implement XInclude substitution
+      XINCLUDE    = 1 << 10
+      # Forbid network access. Recommended for dealing with untrusted documents.
+      NONET       = 1 << 11
+      # Do not reuse the context dictionary
+      NODICT      = 1 << 12
+      # remove redundant namespaces declarations
+      NSCLEAN     = 1 << 13
+      # merge CDATA as text nodes
+      NOCDATA     = 1 << 14
+      # do not generate XINCLUDE START/END nodes
+      NOXINCNODE  = 1 << 15
+      # compact small text nodes; no modification of the tree allowed afterwards (will possibly crash if you try to modify the tree)
+      COMPACT     = 1 << 16
+      # parse using XML-1.0 before update 5
+      OLD10       = 1 << 17
+      # do not fixup XINCLUDE xml:base uris
+      NOBASEFIX   = 1 << 18
+      # relax any hardcoded limit from the parser
+      HUGE        = 1 << 19
+      # line numbers stored as long int (instead of a short int)
+      BIG_LINES   = 1 << 22
+
+      # the default options used for parsing XML documents
+      DEFAULT_XML  = RECOVER | NONET | BIG_LINES
+      # the default options used for parsing XSLT stylesheets
+      DEFAULT_XSLT = RECOVER | NONET | NOENT | DTDLOAD | DTDATTR | NOCDATA | BIG_LINES
+      # the default options used for parsing HTML documents
+      DEFAULT_HTML = RECOVER | NOERROR | NOWARNING | NONET | BIG_LINES
+      # the default options used for parsing XML schemas
+      DEFAULT_SCHEMA = NONET | BIG_LINES
+
+      attr_accessor :options
+
+      def initialize(options = STRICT)
+        @options = options
+      end
+
+      constants.each do |constant|
+        next if constant.to_sym == :STRICT
+        class_eval %{
+          def #{constant.downcase}
+            @options |= #{constant}
+            self
+          end
+
+          def no#{constant.downcase}
+            @options &= ~#{constant}
+            self
+          end
+
+          def #{constant.downcase}?
+            #{constant} & @options == #{constant}
+          end
+        }
+      end
+
+      def strict
+        @options &= ~RECOVER
+        self
+      end
+
+      def strict?
+        @options & RECOVER == STRICT
+      end
+
+      def ==(other)
+        other.to_i == to_i
+      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

data/lib/nokogiri/xml/pp/character_data.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Nokogiri
+  module XML
+    # :nodoc: all
+    module PP
+      module CharacterData
+        def pretty_print(pp)
+          nice_name = self.class.name.split("::").last
+          pp.group(2, "#(#{nice_name} ", ")") do
+            pp.pp(text)
+          end
+        end
+
+        def inspect
+          "#<#{self.class.name}:#{format("0x%x", object_id)} #{text.inspect}>"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Nokogiri
+  module XML
+    # :nodoc: all
+    module PP
+      module Node
+        def inspect
+          attributes = inspect_attributes.reject do |x|
+            attribute = send(x)
+            !attribute || (attribute.respond_to?(:empty?) && attribute.empty?)
+          rescue NoMethodError
+            true
+          end.map do |attribute|
+            "#{attribute.to_s.sub(/_\w+/, "s")}=#{send(attribute).inspect}"
+          end.join(" ")
+          "#<#{self.class.name}:#{format("0x%x", object_id)} #{attributes}>"
+        end
+
+        def pretty_print(pp)
+          nice_name = self.class.name.split("::").last
+          pp.group(2, "#(#{nice_name}:#{format("0x%x", object_id)} {", "})") do
+            pp.breakable
+            attrs = inspect_attributes.map do |t|
+              [t, send(t)] if respond_to?(t)
+            end.compact.find_all do |x|
+              if x.last
+                if [:attribute_nodes, :children].include?(x.first)
+                  !x.last.empty?
+                else
+                  true
+                end
+              end
+            end
+
+            pp.seplist(attrs) do |v|
+              if [:attribute_nodes, :children].include?(v.first)
+                pp.group(2, "#{v.first.to_s.sub(/_\w+$/, "s")} = [", "]") do
+                  pp.breakable
+                  pp.seplist(v.last) do |item|
+                    pp.pp(item)
+                  end
+                end
+              else
+                pp.text("#{v.first} = ")
+                pp.pp(v.last)
+              end
+            end
+            pp.breakable
+          end
+        end
+      end
+    end
+  end
+end

data/lib/nokogiri/xml/pp.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require_relative "pp/node"
+require_relative "pp/character_data"

data/lib/nokogiri/xml/processing_instruction.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Nokogiri
+  module XML
+    class ProcessingInstruction < Node
+      def initialize(document, name, content)
+      end
+    end
+  end
+end