nokogiri 1.6.8.1 → 1.13.4

data/lib/nokogiri/xml/node_set.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Nokogiri
   module XML
     ####
@@ -11,8 +13,10 @@ module Nokogiri
       # 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 = []
+      def initialize(document, list = [])
         @document = document
         document.decorate(self)
         list.each { |x| self << x }
@@ -21,10 +25,11 @@ module Nokogiri
 
       ###
       # Get the first element of the NodeSet.
-      def first n = nil
+      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
 
@@ -41,26 +46,31 @@ 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
 
       ###
       # Insert +datum+ before the first Node in this NodeSet
-      def before datum
-        first.before datum
+      def before(datum)
+        first.before(datum)
       end
 
       ###
       # Insert +datum+ after the last Node in this NodeSet
-      def after datum
-        last.after datum
+      def after(datum)
+        last.after(datum)
       end
 
-      alias :<< :push
-      alias :remove :unlink
+      alias_method :<<, :push
+      alias_method :remove, :unlink
 
       ###
       # call-seq: css *rules, [namespace-bindings, custom-pseudo-class]
@@ -69,11 +79,12 @@ module Nokogiri
       # selectors. For example:
       #
       # For more information see Nokogiri::XML::Searchable#css
-      def css *args
+      def css(*args)
         rules, handler, ns, _ = extract_params(args)
+        paths = css_rules_to_xpath(rules, ns)
 
         inject(NodeSet.new(document)) do |set, node|
-          set += css_internal node, rules, handler, ns
+          set + xpath_internal(node, paths, handler, ns, nil)
         end
       end
 
@@ -84,21 +95,14 @@ module Nokogiri
       # queries.
       #
       # For more information see Nokogiri::XML::Searchable#xpath
-      def xpath *args
+      def xpath(*args)
         paths, handler, ns, binds = extract_params(args)
 
         inject(NodeSet.new(document)) do |set, node|
-          set += node.xpath(*(paths + [ns, handler, binds].compact))
+          set + xpath_internal(node, paths, handler, ns, binds)
         end
       end
 
-      ###
-      # Search this NodeSet's nodes' immediate children using CSS selector +selector+
-      def > selector
-        ns = document.root.namespaces
-        xpath CSS.xpath_for(selector, :prefix => "./", :ns => ns).first
-      end
-
       ###
       # call-seq: search *paths, [namespace-bindings, xpath-variable-bindings, custom-handler-class]
       #
@@ -111,105 +115,155 @@ module Nokogiri
       #
       #   node_set.at(3) # same as node_set[3]
       #
-      def at *args
+      def at(*args)
         if args.length == 1 && args.first.is_a?(Numeric)
           return self[args.first]
         end
 
         super(*args)
       end
-      alias :% :at
+      alias_method :%, :at
 
       ###
       # Filter this list for nodes that match +expr+
-      def filter expr
+      def filter(expr)
         find_all { |node| node.matches?(expr) }
       end
 
       ###
-      # Append the class attribute +name+ to all Node objects in the NodeSet.
-      def add_class name
+      # 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.
-      def remove_class name = nil
+      #
+      # See Nokogiri::XML::Node#append_class for more information.
+      def append_class(name)
         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.append_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)
+      # 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 { |k,v| each { |el| el[k] = v || blk[el] } }
+        hash.each do |k, v|
+          each do |node|
+            node[k] = v || yield(node)
+          end
+        end
 
         self
       end
-      alias :set :attr
-      alias :attribute :attr
+      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 }
+      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(&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('')
+        collect(&:inner_text).join("")
       end
-      alias :text :inner_text
+      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('')
+      def inner_html(*args)
+        collect { |j| j.inner_html(*args) }.join("")
       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
 
       ###
@@ -220,10 +274,10 @@ module Nokogiri
 
       ###
       # Convert this NodeSet to HTML
-      def to_html *args
+      def to_html(*args)
         if Nokogiri.jruby?
           options = args.first.is_a?(Hash) ? args.shift : {}
-          if !options[:save_with]
+          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)
@@ -233,25 +287,26 @@ module Nokogiri
 
       ###
       # Convert this NodeSet to XHTML
-      def to_xhtml *args
+      def to_xhtml(*args)
         map { |x| x.to_xhtml(*args) }.join
       end
 
       ###
       # Convert this NodeSet to XML
-      def to_xml *args
+      def to_xml(*args)
         map { |x| x.to_xml(*args) }.join
       end
 
-      alias :size :length
-      alias :to_ary :to_a
+      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
+
+        delete(last)
       end
 
       ###
@@ -259,16 +314,18 @@ module Nokogiri
       # +nil+ if the set is empty.
       def shift
         return nil if length == 0
-        delete first
+
+        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
+      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
@@ -279,7 +336,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
 
       ###
@@ -288,7 +349,7 @@ module Nokogiri
       def reverse
         node_set = NodeSet.new(document)
         (length - 1).downto(0) do |x|
-          node_set.push self[x]
+          node_set.push(self[x])
         end
         node_set
       end
@@ -296,16 +357,12 @@ module Nokogiri
       ###
       # Return a nicely formated string representation
       def inspect
-        "[#{map(&:inspect).join ', '}]"
+        "[#{map(&:inspect).join(", ")}]"
       end
 
-      alias :+ :|
-
-      private
+      alias_method :+, :|
 
-      def implied_xpath_contexts # :nodoc:
-        [".//", "self::"]
-      end
+      IMPLIED_XPATH_CONTEXTS = [".//", "self::"].freeze # :nodoc:
     end
   end
 end

data/lib/nokogiri/xml/notation.rb

@@ -1,6 +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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Nokogiri
   module XML
     ###
@@ -5,13 +7,13 @@ module Nokogiri
     #
     # == 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. All examples use Ruby 2 optional parameter syntax.
+    # *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.
-    #   <code>Nokogiri.XML('<content>Chapter 1</content', options: Nokogiri::XML::ParseOptions.new((1 << 0) | (1 << 1)))</code>
+    #   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.
-    #   <code>Nokogiri.XML('<content>Chapter 1</content', options: Nokogiri::XML::ParseOptions.new.recover.noent)</code>
+    #   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
-    #   <code>Nokogiri.XML('<content>Chapter 1</content') {|config| config.recover.noent}</code>
+    #   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.
@@ -67,19 +69,27 @@ module Nokogiri
       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
+      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
+      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
+
+      def initialize(options = STRICT)
         @options = options
       end
 
       constants.each do |constant|
         next if constant.to_sym == :STRICT
+
         class_eval %{
           def #{constant.downcase}
             @options |= #{constant}
@@ -106,14 +116,18 @@ module Nokogiri
         @options & RECOVER == STRICT
       end
 
-      alias :to_i :options
+      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(', ') + ">")
+        super.sub(/>$/, " " + options.join(", ") + ">")
       end
     end
   end

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

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

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

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

data/lib/nokogiri/xml/pp.rb

@@ -1,2 +1,4 @@
-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,7 +1,9 @@
+# frozen_string_literal: true
+
 module Nokogiri
   module XML
     class ProcessingInstruction < Node
-      def initialize document, name, content
+      def initialize(document, name, content) # rubocop:disable Style/RedundantInitialize
       end
     end
   end