nokogiri 1.12.2-x86-linux → 1.13.0-x86-linux

data/lib/nokogiri/xml/node_set.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module Nokogiri
   module XML
     ####
@@ -12,10 +13,10 @@ module Nokogiri
       # The Document this NodeSet is associated with
       attr_accessor :document
 
-      alias :clone :dup
+      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 }
@@ -24,7 +25,7 @@ module Nokogiri
 
       ###
       # Get the first element of the NodeSet.
-      def first n = nil
+      def first(n = nil)
         return self[0] unless n
         list = []
         [n, length].min.times { |i| list << self[i] }
@@ -47,7 +48,7 @@ module Nokogiri
       # 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?
+          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) }
@@ -57,18 +58,18 @@ module Nokogiri
 
       ###
       # 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]
@@ -77,7 +78,7 @@ 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)
 
@@ -93,7 +94,7 @@ 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|
@@ -101,13 +102,6 @@ module Nokogiri
         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]
       #
@@ -120,18 +114,18 @@ 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
 
@@ -140,7 +134,7 @@ module Nokogiri
       # NodeSet.
       #
       # See Nokogiri::XML::Node#add_class for more information.
-      def add_class name
+      def add_class(name)
         each do |el|
           el.add_class(name)
         end
@@ -152,7 +146,7 @@ module Nokogiri
       # NodeSet.
       #
       # See Nokogiri::XML::Node#append_class for more information.
-      def append_class name
+      def append_class(name)
         each do |el|
           el.append_class(name)
         end
@@ -164,7 +158,7 @@ module Nokogiri
       # NodeSet.
       #
       # See Nokogiri::XML::Node#remove_class for more information.
-      def remove_class name = nil
+      def remove_class(name = nil)
         each do |el|
           el.remove_class(name)
         end
@@ -204,31 +198,31 @@ module Nokogiri
       #
       #   node_set.attr("class") { |node| node.name }
       #
-      def attr key, value = nil, &block
+      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|
+        hash.each do |k, v|
           each do |node|
-            node[k] = v || block.call(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 remove_attribute remove_attr
+      alias_method :remove_attribute, :remove_attr
 
       ###
       # Iterate over each node, yielding  to +block+
@@ -255,20 +249,20 @@ module Nokogiri
       #
       # 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+
-      def wrap html
-        map { |node| node.wrap html }
+      def wrap(html)
+        map { |node| node.wrap(html) }
       end
 
       ###
@@ -279,10 +273,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)
@@ -292,25 +286,25 @@ 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
 
       ###
@@ -318,14 +312,14 @@ 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|
@@ -351,7 +345,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
@@ -359,14 +353,12 @@ module Nokogiri
       ###
       # Return a nicely formated string representation
       def inspect
-        "[#{map(&:inspect).join ', '}]"
+        "[#{map(&:inspect).join(", ")}]"
       end
 
-      alias :+ :|
-
-      # @private
-      IMPLIED_XPATH_CONTEXTS = [ './/'.freeze, 'self::'.freeze ].freeze # :nodoc:
+      alias_method :+, :|
 
+      IMPLIED_XPATH_CONTEXTS = [".//", "self::"].freeze # :nodoc:
     end
   end
 end

data/lib/nokogiri/xml/notation.rb

@@ -1,7 +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,4 +1,5 @@
 # frozen_string_literal: true
+
 module Nokogiri
   module XML
     ###
@@ -68,18 +69,21 @@ 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
+      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
+      DEFAULT_SCHEMA = NONET | BIG_LINES
 
       attr_accessor :options
-      def initialize options = STRICT
+
+      def initialize(options = STRICT)
         @options = options
       end
 
@@ -115,14 +119,14 @@ module Nokogiri
         other.to_i == to_i
       end
 
-      alias :to_i :options
+      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,17 +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,54 +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,3 +1,4 @@
 # frozen_string_literal: true
+
 require_relative "pp/node"
 require_relative "pp/character_data"

data/lib/nokogiri/xml/processing_instruction.rb

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

data/lib/nokogiri/xml/reader.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module Nokogiri
   module XML
     ###
@@ -8,18 +9,18 @@ module Nokogiri
     #
     # Here is an example of usage:
     #
-    #   reader = Nokogiri::XML::Reader(<<-eoxml)
-    #     <x xmlns:tenderlove='http://tenderlovemaking.com/'>
-    #       <tenderlove:foo awesome='true'>snuggles!</tenderlove:foo>
-    #     </x>
-    #   eoxml
+    #     reader = Nokogiri::XML::Reader(<<-eoxml)
+    #       <x xmlns:tenderlove='http://tenderlovemaking.com/'>
+    #         <tenderlove:foo awesome='true'>snuggles!</tenderlove:foo>
+    #       </x>
+    #     eoxml
     #
-    #   reader.each do |node|
+    #     reader.each do |node|
     #
-    #     # node is an instance of Nokogiri::XML::Reader
-    #     puts node.name
+    #       # node is an instance of Nokogiri::XML::Reader
+    #       puts node.name
     #
-    #   end
+    #     end
     #
     # Note that Nokogiri::XML::Reader#each can only be called once!!  Once
     # the cursor moves through the entire document, you must parse the
@@ -70,28 +71,25 @@ module Nokogiri
       # A list of errors encountered while parsing
       attr_accessor :errors
 
-      # The encoding for the document
-      attr_reader :encoding
-
       # The XML source
       attr_reader :source
 
-      alias :self_closing? :empty_element?
+      alias_method :self_closing?, :empty_element?
 
-      def initialize source, url = nil, encoding = nil # :nodoc:
+      def initialize(source, url = nil, encoding = nil) # :nodoc:
         @source   = source
         @errors   = []
         @encoding = encoding
       end
       private :initialize
 
-      ###
       # Get the attributes of the current node as a Hash
-      # @return [Hash<String, String>] Attribute names and values
+      #
+      # [Returns] (Hash<String, String>) Attribute names and values
       def attributes
         attrs_hash = attribute_nodes.each_with_object({}) do |node, hash|
-                       hash[node.name] = node.to_s
-                     end
+          hash[node.name] = node.to_s
+        end
         ns = namespaces
         attrs_hash.merge!(ns) if ns
         attrs_hash
@@ -100,7 +98,7 @@ module Nokogiri
       ###
       # Move the cursor through the document yielding the cursor to the block
       def each
-        while cursor = self.read
+        while (cursor = read)
           yield cursor
         end
       end

data/lib/nokogiri/xml/relax_ng.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module Nokogiri
   module XML
     class << self

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

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module Nokogiri
   module XML
     ###
@@ -65,7 +66,7 @@ module Nokogiri
       class Document
         ###
         # Called when an XML declaration is parsed
-        def xmldecl version, encoding, standalone
+        def xmldecl(version, encoding, standalone)
         end
 
         ###
@@ -83,13 +84,13 @@ module Nokogiri
         # * +name+ is the name of the tag
         # * +attrs+ are an assoc list of namespaces and attributes, e.g.:
         #     [ ["xmlns:foo", "http://sample.net"], ["size", "large"] ]
-        def start_element name, attrs = []
+        def start_element(name, attrs = [])
         end
 
         ###
         # Called at the end of an element
         # +name+ is the tag name
-        def end_element name
+        def end_element(name)
         end
 
         ###
@@ -99,16 +100,16 @@ module Nokogiri
         # +prefix+ is the namespace prefix for the element
         # +uri+ is the associated namespace URI
         # +ns+ is a hash of namespace prefix:urls associated with the element
-        def start_element_namespace name, attrs = [], prefix = nil, uri = nil, ns = []
+        def start_element_namespace(name, attrs = [], prefix = nil, uri = nil, ns = [])
           ###
           # Deal with SAX v1 interface
-          name = [prefix, name].compact.join(':')
-          attributes = ns.map { |ns_prefix,ns_uri|
-            [['xmlns', ns_prefix].compact.join(':'), ns_uri]
-          } + attrs.map { |attr|
-            [[attr.prefix, attr.localname].compact.join(':'), attr.value]
-          }
-          start_element name, attributes
+          name = [prefix, name].compact.join(":")
+          attributes = ns.map do |ns_prefix, ns_uri|
+            [["xmlns", ns_prefix].compact.join(":"), ns_uri]
+          end + attrs.map do |attr|
+            [[attr.prefix, attr.localname].compact.join(":"), attr.value]
+          end
+          start_element(name, attributes)
         end
 
         ###
@@ -116,10 +117,10 @@ module Nokogiri
         # +name+ is the element's name
         # +prefix+ is the namespace prefix associated with the element
         # +uri+ is the associated namespace URI
-        def end_element_namespace name, prefix = nil, uri = nil
+        def end_element_namespace(name, prefix = nil, uri = nil)
           ###
           # Deal with SAX v1 interface
-          end_element [prefix, name].compact.join(':')
+          end_element([prefix, name].compact.join(":"))
         end
 
         ###
@@ -127,38 +128,38 @@ module Nokogiri
         # times given one contiguous string of characters.
         #
         # +string+ contains the character data
-        def characters string
+        def characters(string)
         end
 
         ###
         # Called when comments are encountered
         # +string+ contains the comment data
-        def comment string
+        def comment(string)
         end
 
         ###
         # Called on document warnings
         # +string+ contains the warning
-        def warning string
+        def warning(string)
         end
 
         ###
         # Called on document errors
         # +string+ contains the error
-        def error string
+        def error(string)
         end
 
         ###
         # Called when cdata blocks are found
         # +string+ contains the cdata content
-        def cdata_block string
+        def cdata_block(string)
         end
 
         ###
         # Called when processing instructions are found
         # +name+ is the target of the instruction
         # +content+ is the value of the instruction
-        def processing_instruction name, content
+        def processing_instruction(name, content)
         end
       end
     end