nokogiri 1.5.10 → 1.12.5

data/lib/nokogiri/xml/node_set.rb

@@ -1,15 +1,19 @@
+# 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::Node#css or Nokogiri::XML::Node#xpath
+    # 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 :clone :dup
+
       # Create a NodeSet with +document+ defaulting to +list+
       def initialize document, list = []
         @document = document
@@ -23,7 +27,7 @@ module Nokogiri
       def first n = nil
         return self[0] unless n
         list = []
-        n.times { |i| list << self[i] }
+        [n, length].min.times { |i| list << self[i] }
         list
       end
 
@@ -40,9 +44,14 @@ module Nokogiri
       end
 
       ###
-      # Returns the index of the first node in self that is == to +node+. Returns nil if no match is found.
-      def index(node)
-        each_with_index { |member, j| return j if member == node }
+      # 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
 
@@ -62,78 +71,34 @@ module Nokogiri
       alias :remove :unlink
 
       ###
-      # Search this document for +paths+
+      # call-seq: css *rules, [namespace-bindings, custom-pseudo-class]
       #
-      # For more information see Nokogiri::XML::Node#css and
-      # Nokogiri::XML::Node#xpath
-      def search *paths
-        handler = ![
-          Hash, String, Symbol
-        ].include?(paths.last.class) ? paths.pop : nil
-
-        ns = paths.last.is_a?(Hash) ? paths.pop : nil
-
-        sub_set = NodeSet.new(document)
-
-        paths.each do |path|
-          sub_set += send(
-            path =~ /^(\.\/|\/|\.\.|\.$)/ ? :xpath : :css,
-            *(paths + [ns, handler]).compact
-          )
-        end
-
-        document.decorate(sub_set)
-        sub_set
-      end
-      alias :/ :search
-
-      ###
-      # Search this NodeSet for css +paths+
+      # Search this node set for CSS +rules+. +rules+ must be one or more CSS
+      # selectors. For example:
       #
-      # For more information see Nokogiri::XML::Node#css
-      def css *paths
-        handler = ![
-          Hash, String, Symbol
-        ].include?(paths.last.class) ? paths.pop : nil
-
-        ns = paths.last.is_a?(Hash) ? paths.pop : nil
-
-        sub_set = NodeSet.new(document)
+      # For more information see Nokogiri::XML::Searchable#css
+      def css *args
+        rules, handler, ns, _ = extract_params(args)
+        paths = css_rules_to_xpath(rules, ns)
 
-        each do |node|
-          doc = node.document
-          search_ns = ns || (doc.root ? doc.root.namespaces : {})
-
-          xpaths = paths.map { |rule|
-            [
-              CSS.xpath_for(rule.to_s, :prefix => ".//", :ns => search_ns),
-              CSS.xpath_for(rule.to_s, :prefix => "self::", :ns => search_ns)
-            ].join(' | ')
-          }
-
-          sub_set += node.xpath(*(xpaths + [search_ns, handler].compact))
+        inject(NodeSet.new(document)) do |set, node|
+          set + xpath_internal(node, paths, handler, ns, nil)
         end
-        document.decorate(sub_set)
-        sub_set
       end
 
       ###
-      # Search this NodeSet for XPath +paths+
+      # call-seq: xpath *paths, [namespace-bindings, variable-bindings, custom-handler-class]
       #
-      # For more information see Nokogiri::XML::Node#xpath
-      def xpath *paths
-        handler = ![
-          Hash, String, Symbol
-        ].include?(paths.last.class) ? paths.pop : nil
-
-        ns = paths.last.is_a?(Hash) ? paths.pop : nil
+      # 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)
 
-        sub_set = NodeSet.new(document)
-        each do |node|
-          sub_set += node.xpath(*(paths + [ns, handler].compact))
+        inject(NodeSet.new(document)) do |set, node|
+          set + xpath_internal(node, paths, handler, ns, binds)
         end
-        document.decorate(sub_set)
-        sub_set
       end
 
       ###
@@ -144,31 +109,25 @@ module Nokogiri
       end
 
       ###
-      # If path is a string, search this document for +path+ returning the
-      # first Node.  Otherwise, index in to the array with +path+.
-      def at path, ns = document.root ? document.root.namespaces : {}
-        return self[path] if path.is_a?(Numeric)
-        search(path, ns).first
-      end
-      alias :% :at
-
-      ##
-      # Search this NodeSet for the first occurrence of XPath +paths+.
-      # Equivalent to <tt>xpath(paths).first</tt>
-      # See NodeSet#xpath for more information.
+      # call-seq: search *paths, [namespace-bindings, xpath-variable-bindings, custom-handler-class]
       #
-      def at_xpath *paths
-        xpath(*paths).first
-      end
-
-      ##
-      # Search this NodeSet for the first occurrence of CSS +rules+.
-      # Equivalent to <tt>css(rules).first</tt>
-      # See NodeSet#css for more information.
+      # 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:
       #
-      def at_css *rules
-        css(*rules).first
+      #   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 :% :at
 
       ###
       # Filter this list for nodes that match +expr+
@@ -177,46 +136,86 @@ module Nokogiri
       end
 
       ###
-      # Append the class attribute +name+ to all Node objects in the NodeSet.
+      # 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|
-          classes = el['class'].to_s.split(/\s+/)
-          el['class'] = classes.push(name).uniq.join " "
+          el.add_class(name)
         end
         self
       end
 
       ###
-      # Remove the class attribute +name+ from all Node objects in the NodeSet.
-      # If +name+ is nil, remove the class attribute from all Nodes in the
+      # 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|
-          if name
-            classes = el['class'].to_s.split(/\s+/)
-            if classes.empty?
-              el.delete 'class'
-            else
-              el['class'] = (classes - [name]).uniq.join " "
-            end
-          else
-            el.delete "class"
-          end
+          el.remove_class(name)
         end
         self
       end
 
       ###
-      # Set the attribute +key+ to +value+ or the return value of +blk+
-      # on all Node objects in the NodeSet.
-      def attr key, value = nil, &blk
-        unless Hash === key || key && (value || blk)
-          return first.attribute(key)
+      # 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 { |k,v| each { |el| el[k] = v || blk[el] } }
+        hash.each do |k,v|
+          each do |node|
+            node[k] = v || block.call(node)
+          end
+        end
 
         self
       end
@@ -229,19 +228,34 @@ module Nokogiri
         each { |el| el.delete name }
         self
       end
+      alias remove_attribute remove_attr
 
       ###
       # Iterate over each node, yielding  to +block+
-      def each(&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{|j| j.inner_text}.join('')
+        collect(&:inner_text).join('')
       end
       alias :text :inner_text
 
@@ -252,20 +266,15 @@ module Nokogiri
       end
 
       ###
-      # Wrap this NodeSet with +html+ or the results of the builder in +blk+
-      def wrap(html, &blk)
-        each do |j|
-          new_parent = document.parse(html).first
-          j.add_next_sibling(new_parent)
-          new_parent.add_child(j)
-        end
-        self
+      # Wrap this NodeSet with +html+
+      def wrap html
+        map { |node| node.wrap html }
       end
 
       ###
       # Convert this NodeSet to a string.
       def to_s
-        map { |x| x.to_s }.join
+        map(&:to_s).join
       end
 
       ###
@@ -329,7 +338,11 @@ module Nokogiri
       # Returns a new NodeSet containing all the children of all the nodes in
       # the NodeSet
       def children
-        inject(NodeSet.new(document)) { |set, node| set += node.children }
+        node_set = NodeSet.new(document)
+        each do |node|
+          node.children.each { |n| node_set.push(n) }
+        end
+        node_set
       end
 
       ###
@@ -346,10 +359,14 @@ module Nokogiri
       ###
       # Return a nicely formated string representation
       def inspect
-        "[#{map { |c| c.inspect }.join ', '}]"
+        "[#{map(&:inspect).join ', '}]"
       end
 
       alias :+ :|
+
+      # @private
+      IMPLIED_XPATH_CONTEXTS = [ './/'.freeze, 'self::'.freeze ].freeze # :nodoc:
+
     end
   end
 end

data/lib/nokogiri/xml/notation.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Nokogiri
   module XML
     class Notation < Struct.new(:name, :public_id, :system_id)

data/lib/nokogiri/xml/parse_options.rb

@@ -1,7 +1,30 @@
+# 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
@@ -48,8 +71,12 @@ module Nokogiri
 
       # the default options used for parsing XML documents
       DEFAULT_XML  = RECOVER | NONET
+      # the default options used for parsing XSLT stylesheets
+      DEFAULT_XSLT = RECOVER | NONET | NOENT | DTDLOAD | DTDATTR | NOCDATA
       # the default options used for parsing HTML documents
       DEFAULT_HTML = RECOVER | NOERROR | NOWARNING | NONET
+      # the default options used for parsing XML schemas
+      DEFAULT_SCHEMA = NONET
 
       attr_accessor :options
       def initialize options = STRICT
@@ -84,6 +111,10 @@ module Nokogiri
         @options & RECOVER == STRICT
       end
 
+      def ==(other)
+        other.to_i == to_i
+      end
+
       alias :to_i :options
 
       def inspect

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

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Nokogiri
   module XML
     module PP

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

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Nokogiri
   module XML
     module PP

data/lib/nokogiri/xml/pp.rb

@@ -1,2 +1,3 @@
-require 'nokogiri/xml/pp/node'
-require 'nokogiri/xml/pp/character_data'
+# frozen_string_literal: true
+require_relative "pp/node"
+require_relative "pp/character_data"

data/lib/nokogiri/xml/processing_instruction.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Nokogiri
   module XML
     class ProcessingInstruction < Node

data/lib/nokogiri/xml/reader.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Nokogiri
   module XML
     ###
@@ -85,19 +86,15 @@ module Nokogiri
       private :initialize
 
       ###
-      # Get a list of attributes for the current node.
+      # Get the attributes of the current node as a Hash
+      # @return [Hash<String, String>] Attribute names and values
       def attributes
-        Hash[attribute_nodes.map { |node|
-          [node.name, node.to_s]
-        }].merge(namespaces || {})
-      end
-
-      ###
-      # Get a list of attributes for the current node
-      def attribute_nodes
-        nodes = attr_nodes
-        nodes.each { |v| v.instance_variable_set(:@_r, self) }
-        nodes
+        attrs_hash = attribute_nodes.each_with_object({}) do |node, hash|
+                       hash[node.name] = node.to_s
+                     end
+        ns = namespaces
+        attrs_hash.merge!(ns) if ns
+        attrs_hash
       end
 
       ###

data/lib/nokogiri/xml/relax_ng.rb

@@ -1,11 +1,12 @@
+# frozen_string_literal: true
 module Nokogiri
   module XML
     class << self
       ###
       # Create a new Nokogiri::XML::RelaxNG document from +string_or_io+.
       # See Nokogiri::XML::RelaxNG for an example.
-      def RelaxNG string_or_io
-        RelaxNG.new(string_or_io)
+      def RelaxNG(string_or_io, options = ParseOptions::DEFAULT_SCHEMA)
+        RelaxNG.new(string_or_io, options)
       end
     end
 
@@ -26,6 +27,10 @@ module Nokogiri
     #   end
     #
     # The list of errors are Nokogiri::XML::SyntaxError objects.
+    #
+    # NOTE: RelaxNG input is always treated as TRUSTED documents, meaning that they will cause the
+    # underlying parsing libraries to access network resources. This is counter to Nokogiri's
+    # "untrusted by default" security policy, but is a limitation of the underlying libraries.
     class RelaxNG < Nokogiri::XML::Schema
     end
   end

data/lib/nokogiri/xml/sax/document.rb

@@ -1,20 +1,20 @@
+# frozen_string_literal: true
 module Nokogiri
   module XML
     ###
-    # SAX Parsers are event driven parsers.  Nokogiri provides two different
-    # event based parsers when dealing with XML.  If you want to do SAX style
-    # parsing using HTML, check out Nokogiri::HTML::SAX.
+    # SAX Parsers are event driven parsers. Nokogiri provides two different event based parsers when
+    # dealing with XML. If you want to do SAX style parsing using HTML, check out
+    # Nokogiri::HTML4::SAX.
     #
-    # The basic way a SAX style parser works is by creating a parser,
-    # telling the parser about the events we're interested in, then giving
-    # the parser some XML to process.  The parser will notify you when
-    # it encounters events your said you would like to know about.
+    # The basic way a SAX style parser works is by creating a parser, telling the parser about the
+    # events we're interested in, then giving the parser some XML to process. The parser will notify
+    # you when it encounters events you said you would like to know about.
     #
-    # To register for events, you simply subclass Nokogiri::XML::SAX::Document,
-    # and implement the methods for which you would like notification.
+    # To register for events, you simply subclass Nokogiri::XML::SAX::Document, and implement the
+    # methods for which you would like notification.
     #
-    # For example, if I want to be notified when a document ends, and when an
-    # element starts, I would write a class like this:
+    # For example, if I want to be notified when a document ends, and when an element starts, I
+    # would write a class like this:
     #
     #   class MyDocument < Nokogiri::XML::SAX::Document
     #     def end_document
@@ -26,8 +26,7 @@ module Nokogiri
     #     end
     #   end
     #
-    # Then I would instantiate a SAX parser with this document, and feed the
-    # parser some XML
+    # Then I would instantiate a SAX parser with this document, and feed the parser some XML
     #
     #   # Create a new parser
     #   parser = Nokogiri::XML::SAX::Parser.new(MyDocument.new)
@@ -35,25 +34,21 @@ module Nokogiri
     #   # Feed the parser some XML
     #   parser.parse(File.open(ARGV[0]))
     #
-    # Now my document handler will be called when each node starts, and when
-    # then document ends.  To see what kinds of events are available, take
-    # a look at Nokogiri::XML::SAX::Document.
+    # Now my document handler will be called when each node starts, and when then document ends. To
+    # see what kinds of events are available, take a look at Nokogiri::XML::SAX::Document.
     #
-    # Two SAX parsers for XML are available, a parser that reads from a string
-    # or IO object as it feels necessary, and a parser that lets you spoon
-    # feed it XML.  If you want to let Nokogiri deal with reading your XML,
-    # use the Nokogiri::XML::SAX::Parser.  If you want to have fine grain
+    # Two SAX parsers for XML are available, a parser that reads from a string or IO object as it
+    # feels necessary, and a parser that lets you spoon feed it XML. If you want to let Nokogiri
+    # deal with reading your XML, use the Nokogiri::XML::SAX::Parser. If you want to have fine grain
     # control over the XML input, use the Nokogiri::XML::SAX::PushParser.
     module SAX
       ###
-      # This class is used for registering types of events you are interested
-      # in handling.  All of the methods on this class are available as
-      # possible events while parsing an XML document.  To register for any
-      # particular event, just subclass this class and implement the methods
-      # you are interested in knowing about.
+      # This class is used for registering types of events you are interested in handling. All of
+      # the methods on this class are available as possible events while parsing an XML document. To
+      # register for any particular event, just subclass this class and implement the methods you
+      # are interested in knowing about.
       #
-      # To only be notified about start and end element events, write a class
-      # like this:
+      # To only be notified about start and end element events, write a class like this:
       #
       #   class MyDocument < Nokogiri::XML::SAX::Document
       #     def start_element name, attrs = []
@@ -65,8 +60,8 @@ module Nokogiri
       #     end
       #   end
       #
-      # You can use this event handler for any SAX style parser included with
-      # Nokogiri.  See Nokogiri::XML::SAX, and Nokogiri::HTML::SAX.
+      # You can use this event handler for any SAX style parser included with Nokogiri. See
+      # Nokogiri::XML::SAX, and Nokogiri::HTML4::SAX.
       class Document
         ###
         # Called when an XML declaration is parsed
@@ -128,7 +123,7 @@ module Nokogiri
         end
 
         ###
-        # Characters read between a tag.  This method might be called multiple
+        # Characters read between a tag. This method might be called multiple
         # times given one contiguous string of characters.
         #
         # +string+ contains the character data

data/lib/nokogiri/xml/sax/parser.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Nokogiri
   module XML
     module SAX
@@ -68,8 +69,7 @@ module Nokogiri
 
         # Create a new Parser with +doc+ and +encoding+
         def initialize doc = Nokogiri::XML::SAX::Document.new, encoding = 'UTF-8'
-          check_encoding(encoding)
-          @encoding = encoding
+          @encoding = check_encoding(encoding)
           @document = doc
           @warned   = false
         end
@@ -88,9 +88,8 @@ module Nokogiri
         ###
         # Parse given +io+
         def parse_io io, encoding = 'ASCII'
-          check_encoding(encoding)
-          @encoding = encoding
-          ctx = ParserContext.io(io, ENCODINGS[encoding])
+          @encoding = check_encoding(encoding)
+          ctx = ParserContext.io(io, ENCODINGS[@encoding])
           yield ctx if block_given?
           ctx.parse_with self
         end
@@ -99,7 +98,7 @@ module Nokogiri
         # Parse a file with +filename+
         def parse_file filename
           raise ArgumentError unless filename
-          raise Errno::ENOENT unless File.exists?(filename)
+          raise Errno::ENOENT unless File.exist?(filename)
           raise Errno::EISDIR if File.directory?(filename)
           ctx = ParserContext.file filename
           yield ctx if block_given?
@@ -114,8 +113,9 @@ module Nokogiri
 
         private
         def check_encoding(encoding)
-          encoding.upcase!
-          raise ArgumentError.new("'#{encoding}' is not a valid encoding") unless ENCODINGS[encoding]
+          encoding.upcase.tap do |enc|
+            raise ArgumentError.new("'#{enc}' is not a valid encoding") unless ENCODINGS[enc]
+          end
         end
       end
     end