nokogiri 1.12.5-x86_64-darwin → 1.13.3-x86_64-darwin

data/lib/nokogiri/css/parser.y

@@ -5,256 +5,261 @@ token COMMA NUMBER PREFIXMATCH SUFFIXMATCH SUBSTRINGMATCH TILDE NOT_EQUAL
 token SLASH DOUBLESLASH NOT EQUAL RPAREN LSQUARE RSQUARE HAS
 
 rule
-  selector
-    : selector COMMA simple_selector_1toN {
-        result = [val.first, val.last].flatten
-      }
-    | prefixless_combinator_selector { result = val.flatten }
-    | optional_S simple_selector_1toN { result = [val.last].flatten }
-    ;
-  combinator
-    : PLUS { result = :DIRECT_ADJACENT_SELECTOR }
-    | GREATER { result = :CHILD_SELECTOR }
-    | TILDE { result = :FOLLOWING_SELECTOR }
-    | DOUBLESLASH { result = :DESCENDANT_SELECTOR }
-    | SLASH { result = :CHILD_SELECTOR }
-    ;
-  simple_selector
-    : element_name hcap_0toN {
-        result =  if val[1].nil?
-                    val.first
-                  else
-                    Node.new(:CONDITIONAL_SELECTOR, [val.first, val[1]])
-                  end
-      }
-    | function
-    | function pseudo {
-        result = Node.new(:CONDITIONAL_SELECTOR, val)
-      }
-    | function attrib {
-        result = Node.new(:CONDITIONAL_SELECTOR, val)
-      }
-    | hcap_1toN {
-        result = Node.new(:CONDITIONAL_SELECTOR,
-          [Node.new(:ELEMENT_NAME, ['*']), val.first]
-        )
-      }
-    ;
-  prefixless_combinator_selector
-    : combinator simple_selector_1toN {
-        result = Node.new(val.first, [nil, val.last])
-      }
-    ;
-  simple_selector_1toN
-    : simple_selector combinator simple_selector_1toN {
-        result = Node.new(val[1], [val.first, val.last])
-      }
-    | simple_selector S simple_selector_1toN {
-        result = Node.new(:DESCENDANT_SELECTOR, [val.first, val.last])
-      }
-    | simple_selector
-    ;
-  class
-    : '.' IDENT { result = Node.new(:CLASS_CONDITION, [unescape_css_identifier(val[1])]) }
-    ;
-  element_name
-    : namespaced_ident
-    | '*' { result = Node.new(:ELEMENT_NAME, val) }
-    ;
-  namespaced_ident
-    : namespace '|' IDENT {
-        result = Node.new(:ELEMENT_NAME,
-          [[val.first, val.last].compact.join(':')]
-        )
-      }
-    | IDENT {
-        name = @namespaces.key?('xmlns') ? "xmlns:#{val.first}" : val.first
-        result = Node.new(:ELEMENT_NAME, [name])
-      }
-    ;
-  namespace
-    : IDENT { result = val[0] }
-    |
-    ;
-  attrib
-    : LSQUARE attrib_name attrib_val_0or1 RSQUARE {
-        result = Node.new(:ATTRIBUTE_CONDITION,
-          [val[1]] + (val[2] || [])
-        )
-      }
-    | LSQUARE function attrib_val_0or1 RSQUARE {
-        result = Node.new(:ATTRIBUTE_CONDITION,
-          [val[1]] + (val[2] || [])
-        )
-      }
-    | LSQUARE NUMBER RSQUARE {
-        # non-standard, from hpricot
-        result = Node.new(:PSEUDO_CLASS,
-          [Node.new(:FUNCTION, ['nth-child(', val[1]])]
-        )
-      }
-    ;
-  attrib_name
-    : namespace '|' IDENT {
-        result = Node.new(:ELEMENT_NAME,
-          [[val.first, val.last].compact.join(':')]
-        )
-      }
-    | IDENT {
-        # Default namespace is not applied to attributes.
-        # So we don't add prefix "xmlns:" as in namespaced_ident.
-        result = Node.new(:ELEMENT_NAME, [val.first])
-      }
-    ;
-  function
-    : FUNCTION RPAREN {
-        result = Node.new(:FUNCTION, [val.first.strip])
-      }
-    | FUNCTION expr RPAREN {
-        result = Node.new(:FUNCTION, [val.first.strip, val[1]].flatten)
-      }
-    | FUNCTION nth RPAREN {
-        result = Node.new(:FUNCTION, [val.first.strip, val[1]].flatten)
-      }
-    | NOT expr RPAREN {
-        result = Node.new(:FUNCTION, [val.first.strip, val[1]].flatten)
-      }
-    | HAS selector RPAREN {
-        result = Node.new(:FUNCTION, [val.first.strip, val[1]].flatten)
-      }
-    ;
-  expr
-    : NUMBER COMMA expr { result = [val.first, val.last] }
-    | STRING COMMA expr { result = [val.first, val.last] }
-    | IDENT COMMA expr { result = [val.first, val.last] }
-    | NUMBER
-    | STRING
-    | IDENT                             # even, odd
-      {
-        case val[0]
-        when 'even'
-          result = Node.new(:NTH, ['2','n','+','0'])
-        when 'odd'
-          result = Node.new(:NTH, ['2','n','+','1'])
-        when 'n'
-          result = Node.new(:NTH, ['1','n','+','0'])
-        else
-          # non-standard to support custom functions:
-          # assert_xpath("//a[foo(., @href)]", @parser.parse('a:foo(@href)'))
-          # assert_xpath("//a[foo(., @a, b)]", @parser.parse('a:foo(@a, b)'))
-          # assert_xpath("//a[foo(., a, 10)]", @parser.parse('a:foo(a, 10)'))
-          result = val
-        end
-      }
-    ;
-  nth
-    : NUMBER IDENT PLUS NUMBER          # 5n+3 -5n+3
-      {
-        if val[1] == 'n'
-          result = Node.new(:NTH, val)
-        else
-          raise Racc::ParseError, "parse error on IDENT '#{val[1]}'"
-        end
-      }
-    | IDENT PLUS NUMBER {               # n+3, -n+3
-        if val[0] == 'n'
-          val.unshift("1")
-          result = Node.new(:NTH, val)
-        elsif val[0] == '-n'
-          val[0] = 'n'
-          val.unshift("-1")
-          result = Node.new(:NTH, val)
-        else
-          raise Racc::ParseError, "parse error on IDENT '#{val[1]}'"
-        end
-      }
-    | NUMBER IDENT {                    # 5n, -5n, 10n-1
-        n = val[1]
-        if n[0, 2] == 'n-'
-          val[1] = 'n'
-          val << "-"
-          # b is contained in n as n is the string "n-b"
-          val << n[2, n.size]
-          result = Node.new(:NTH, val)
-        elsif n == 'n'
-          val << "+"
-          val << "0"
-          result = Node.new(:NTH, val)
-        else
-          raise Racc::ParseError, "parse error on IDENT '#{val[1]}'"
-        end
-      }
-    ;
-  pseudo
-    : ':' function {
-        result = Node.new(:PSEUDO_CLASS, [val[1]])
-      }
-    | ':' IDENT { result = Node.new(:PSEUDO_CLASS, [val[1]]) }
-    ;
-  hcap_0toN
-    : hcap_1toN
-    |
-    ;
-  hcap_1toN
-    : attribute_id hcap_1toN {
-        result = Node.new(:COMBINATOR, val)
-      }
-    | class hcap_1toN {
-        result = Node.new(:COMBINATOR, val)
-      }
-    | attrib hcap_1toN {
-        result = Node.new(:COMBINATOR, val)
-      }
-    | pseudo hcap_1toN {
-        result = Node.new(:COMBINATOR, val)
-      }
-    | negation hcap_1toN {
-        result = Node.new(:COMBINATOR, val)
-      }
-    | attribute_id
-    | class
-    | attrib
-    | pseudo
-    | negation
-    ;
-  attribute_id
-    : HASH { result = Node.new(:ID, [unescape_css_identifier(val.first)]) }
-    ;
-  attrib_val_0or1
-    : eql_incl_dash IDENT { result = [val.first, unescape_css_identifier(val[1])] }
-    | eql_incl_dash STRING { result = [val.first, unescape_css_string(val[1])] }
-    | eql_incl_dash NUMBER { result = [val.first, val[1]] }
-    |
-    ;
-  eql_incl_dash
-    : EQUAL           { result = :equal }
-    | PREFIXMATCH     { result = :prefix_match }
-    | SUFFIXMATCH     { result = :suffix_match }
-    | SUBSTRINGMATCH  { result = :substring_match }
-    | NOT_EQUAL       { result = :not_equal }
-    | INCLUDES        { result = :includes }
-    | DASHMATCH       { result = :dash_match }
-    ;
-  negation
-    : NOT negation_arg RPAREN {
-        result = Node.new(:NOT, [val[1]])
-      }
-    ;
-  negation_arg
-    : element_name
-    | element_name hcap_1toN
-    | hcap_1toN
-    ;
-  optional_S
-    : S
-    |
-    ;
+  selector:
+    selector COMMA simple_selector_1toN {
+      result = [val[0], val[2]].flatten
+    }
+  | prefixless_combinator_selector { result = val.flatten }
+  | optional_S simple_selector_1toN { result = [val[1]].flatten }
+  ;
+
+  combinator:
+    PLUS { result = :DIRECT_ADJACENT_SELECTOR }
+  | GREATER { result = :CHILD_SELECTOR }
+  | TILDE { result = :FOLLOWING_SELECTOR }
+  | DOUBLESLASH { result = :DESCENDANT_SELECTOR }
+  | SLASH { result = :CHILD_SELECTOR }
+  ;
+
+  xpath_attribute_name:
+    '@' IDENT { result = val[1] }
+  ;
+
+  xpath_attribute:
+    xpath_attribute_name { result = Node.new(:ATTRIB_NAME, [val[0]]) }
+  ;
+
+  simple_selector:
+    element_name hcap_0toN {
+      result =  if val[1].nil?
+                  val[0]
+                else
+                  Node.new(:CONDITIONAL_SELECTOR, [val[0], val[1]])
+                end
+    }
+  | function
+  | function pseudo { result = Node.new(:CONDITIONAL_SELECTOR, val) }
+  | function attrib { result = Node.new(:CONDITIONAL_SELECTOR, val) }
+  | hcap_1toN { result = Node.new(:CONDITIONAL_SELECTOR, [Node.new(:ELEMENT_NAME, ['*']), val[0]]) }
+  | xpath_attribute
+  ;
+
+  prefixless_combinator_selector:
+    combinator simple_selector_1toN { result = Node.new(val[0], [nil, val[1]]) }
+  ;
+
+  simple_selector_1toN:
+    simple_selector combinator simple_selector_1toN { result = Node.new(val[1], [val[0], val[2]]) }
+  | simple_selector S simple_selector_1toN { result = Node.new(:DESCENDANT_SELECTOR, [val[0], val[2]]) }
+  | simple_selector
+  ;
+
+  class:
+    '.' IDENT { result = Node.new(:CLASS_CONDITION, [unescape_css_identifier(val[1])]) }
+  ;
+
+  element_name:
+    namespaced_ident
+  | '*' { result = Node.new(:ELEMENT_NAME, val) }
+  ;
+
+  namespaced_ident:
+    namespace '|' IDENT { result = Node.new(:ELEMENT_NAME, [[val[0], val[2]].compact.join(':')]) }
+  | IDENT {
+      name = @namespaces.key?('xmlns') ? "xmlns:#{val[0]}" : val[0]
+      result = Node.new(:ELEMENT_NAME, [name])
+    }
+  ;
+
+  namespace:
+    IDENT { result = val[0] }
+  |
+  ;
+
+  attrib:
+    LSQUARE attrib_name attrib_val_0or1 RSQUARE {
+      result = Node.new(:ATTRIBUTE_CONDITION, [val[1]] + (val[2] || []))
+    }
+  | LSQUARE function attrib_val_0or1 RSQUARE {
+      result = Node.new(:ATTRIBUTE_CONDITION, [val[1]] + (val[2] || []))
+    }
+  | LSQUARE NUMBER RSQUARE {
+      result = Node.new(:PSEUDO_CLASS, [Node.new(:FUNCTION, ['nth-child(', val[1]])])
+    }
+  ;
+
+  attrib_name:
+    namespace '|' IDENT { result = Node.new(:ATTRIB_NAME, [[val[0], val[2]].compact.join(':')]) }
+  | IDENT { result = Node.new(:ATTRIB_NAME, [val[0]]) }
+  | xpath_attribute
+  ;
+
+  function:
+    FUNCTION RPAREN {
+      result = Node.new(:FUNCTION, [val[0].strip])
+    }
+  | FUNCTION expr RPAREN {
+      result = Node.new(:FUNCTION, [val[0].strip, val[1]].flatten)
+    }
+  | FUNCTION nth RPAREN {
+      result = Node.new(:FUNCTION, [val[0].strip, val[1]].flatten)
+    }
+  | NOT expr RPAREN {
+      result = Node.new(:FUNCTION, [val[0].strip, val[1]].flatten)
+    }
+  | HAS selector RPAREN {
+      result = Node.new(:FUNCTION, [val[0].strip, val[1]].flatten)
+    }
+  ;
+
+  expr:
+    NUMBER COMMA expr { result = [val[0], val[2]] }
+  | STRING COMMA expr { result = [val[0], val[2]] }
+  | IDENT COMMA expr { result = [val[0], val[2]] }
+  | xpath_attribute COMMA expr { result = [val[0], val[2]] }
+  | NUMBER
+  | STRING
+  | IDENT {
+      case val[0]
+      when 'even'
+        result = Node.new(:NTH, ['2','n','+','0'])
+      when 'odd'
+        result = Node.new(:NTH, ['2','n','+','1'])
+      when 'n'
+        result = Node.new(:NTH, ['1','n','+','0'])
+      else
+        result = val
+      end
+    }
+  | xpath_attribute
+  ;
+
+  nth:
+    NUMBER IDENT PLUS NUMBER          # 5n+3 -5n+3
+    {
+      if val[1] == 'n'
+        result = Node.new(:NTH, val)
+      else
+        raise Racc::ParseError, "parse error on IDENT '#{val[1]}'"
+      end
+    }
+  | IDENT PLUS NUMBER {               # n+3, -n+3
+      if val[0] == 'n'
+        val.unshift("1")
+        result = Node.new(:NTH, val)
+      elsif val[0] == '-n'
+        val[0] = 'n'
+        val.unshift("-1")
+        result = Node.new(:NTH, val)
+      else
+        raise Racc::ParseError, "parse error on IDENT '#{val[1]}'"
+      end
+    }
+  | NUMBER IDENT {                    # 5n, -5n, 10n-1
+      n = val[1]
+      if n[0, 2] == 'n-'
+        val[1] = 'n'
+        val << "-"
+        # b is contained in n as n is the string "n-b"
+        val << n[2, n.size]
+        result = Node.new(:NTH, val)
+      elsif n == 'n'
+        val << "+"
+        val << "0"
+        result = Node.new(:NTH, val)
+      else
+        raise Racc::ParseError, "parse error on IDENT '#{val[1]}'"
+      end
+    }
+  ;
+
+  pseudo:
+    ':' function {
+      result = Node.new(:PSEUDO_CLASS, [val[1]])
+    }
+  | ':' IDENT { result = Node.new(:PSEUDO_CLASS, [val[1]]) }
+  ;
+
+  hcap_0toN:
+    hcap_1toN
+  |
+  ;
+
+  hcap_1toN:
+    attribute_id hcap_1toN {
+      result = Node.new(:COMBINATOR, val)
+    }
+  | class hcap_1toN {
+      result = Node.new(:COMBINATOR, val)
+    }
+  | attrib hcap_1toN {
+      result = Node.new(:COMBINATOR, val)
+    }
+  | pseudo hcap_1toN {
+      result = Node.new(:COMBINATOR, val)
+    }
+  | negation hcap_1toN {
+      result = Node.new(:COMBINATOR, val)
+    }
+  | attribute_id
+  | class
+  | attrib
+  | pseudo
+  | negation
+  ;
+
+  attribute_id:
+    HASH { result = Node.new(:ID, [unescape_css_identifier(val[0])]) }
+  ;
+
+  attrib_val_0or1:
+    eql_incl_dash IDENT { result = [val[0], unescape_css_identifier(val[1])] }
+  | eql_incl_dash STRING { result = [val[0], unescape_css_string(val[1])] }
+  | eql_incl_dash NUMBER { result = [val[0], val[1]] }
+  |
+  ;
+
+  eql_incl_dash:
+    EQUAL           { result = :equal }
+  | PREFIXMATCH     { result = :prefix_match }
+  | SUFFIXMATCH     { result = :suffix_match }
+  | SUBSTRINGMATCH  { result = :substring_match }
+  | NOT_EQUAL       { result = :not_equal }
+  | INCLUDES        { result = :includes }
+  | DASHMATCH       { result = :dash_match }
+  ;
+
+  negation:
+    NOT negation_arg RPAREN {
+      result = Node.new(:NOT, [val[1]])
+    }
+  ;
+
+  negation_arg:
+    element_name
+  | element_name hcap_1toN
+  | hcap_1toN
+  ;
+
+  optional_S:
+    S
+  |
+  ;
+
 end
 
 ---- header
 
 require_relative "parser_extras"
 
+module Nokogiri
+  module CSS
+    # :nodoc: all
+    class Parser < Racc::Parser
+    end
+  end
+end
+
 ---- inner
 
 def unescape_css_identifier(identifier)

data/lib/nokogiri/css/parser_extras.rb

@@ -1,9 +1,10 @@
 # frozen_string_literal: true
+
 require "thread"
 
 module Nokogiri
   module CSS
-    class Parser < Racc::Parser
+    class Parser < Racc::Parser # :nodoc:
       CACHE_SWITCH_NAME = :nokogiri_css_parser_cache_is_off
 
       @cache = {}
@@ -16,13 +17,13 @@ module Nokogiri
         end
 
         # Set a thread-local boolean to turn cacheing on and off. Truthy values turn the cache on, falsey values turn the cache off.
-        def set_cache(value)
+        def set_cache(value) # rubocop:disable Naming/AccessorMethodName
           Thread.current[CACHE_SWITCH_NAME] = !value
         end
 
         # Get the css selector in +string+ from the cache
         def [](string)
-          return unless cache_on?
+          return nil unless cache_on?
           @mutex.synchronize { @cache[string] }
         end
 
@@ -46,10 +47,10 @@ module Nokogiri
         # Execute +block+ without cache
         def without_cache(&block)
           original_cache_setting = cache_on?
-          set_cache false
-          block.call
+          set_cache(false)
+          yield
         ensure
-          set_cache original_cache_setting
+          set_cache(original_cache_setting)
         end
       end
 
@@ -61,7 +62,7 @@ module Nokogiri
       end
 
       def parse(string)
-        @tokenizer.scan_setup string
+        @tokenizer.scan_setup(string)
         do_parse
       end
 
@@ -70,24 +71,23 @@ module Nokogiri
       end
 
       # Get the xpath for +string+ using +options+
-      def xpath_for(string, options = {})
-        key = "#{string}#{options[:ns]}#{options[:prefix]}"
-        v = self.class[key]
-        return v if v
-
-        args = [
-          options[:prefix] || "//",
-          options[:visitor] || XPathVisitor.new,
-        ]
-        self.class[key] = parse(string).map { |ast|
-          ast.to_xpath(*args)
-        }
+      def xpath_for(string, prefix, visitor)
+        key = cache_key(string, prefix, visitor)
+        self.class[key] ||= parse(string).map do |ast|
+          ast.to_xpath(prefix, visitor)
+        end
       end
 
       # On CSS parser error, raise an exception
       def on_error(error_token_id, error_value, value_stack)
         after = value_stack.compact.last
-        raise SyntaxError.new("unexpected '#{error_value}' after '#{after}'")
+        raise SyntaxError, "unexpected '#{error_value}' after '#{after}'"
+      end
+
+      def cache_key(query, prefix, visitor)
+        if self.class.cache_on?
+          [query, prefix, @namespaces, visitor.config]
+        end
       end
     end
   end

data/lib/nokogiri/css/syntax_error.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require_relative "../syntax_error"
 module Nokogiri
   module CSS

data/lib/nokogiri/css/tokenizer.rb

@@ -7,7 +7,8 @@
 
 module Nokogiri
 module CSS
-class Tokenizer # :nodoc:
+# :nodoc: all
+class Tokenizer
       require 'strscan'
 
       class ScanError < StandardError ; end
@@ -62,10 +63,10 @@ class Tokenizer # :nodoc:
                   when (text = @ss.scan(/has\([\s]*/))
                      action { [:HAS, text] }
 
-                  when (text = @ss.scan(/[-@]?([_A-Za-z]|[^\0-\177]|\\[0-9A-Fa-f]{1,6}(\r\n|[\s])?|\\[^\n\r\f0-9A-Fa-f])([_A-Za-z0-9-]|[^\0-\177]|\\[0-9A-Fa-f]{1,6}(\r\n|[\s])?|\\[^\n\r\f0-9A-Fa-f])*\([\s]*/))
+                  when (text = @ss.scan(/-?([_A-Za-z]|[^\0-\177]|\\[0-9A-Fa-f]{1,6}(\r\n|[\s])?|\\[^\n\r\f0-9A-Fa-f])([_A-Za-z0-9-]|[^\0-\177]|\\[0-9A-Fa-f]{1,6}(\r\n|[\s])?|\\[^\n\r\f0-9A-Fa-f])*\([\s]*/))
                      action { [:FUNCTION, text] }
 
-                  when (text = @ss.scan(/[-@]?([_A-Za-z]|[^\0-\177]|\\[0-9A-Fa-f]{1,6}(\r\n|[\s])?|\\[^\n\r\f0-9A-Fa-f])([_A-Za-z0-9-]|[^\0-\177]|\\[0-9A-Fa-f]{1,6}(\r\n|[\s])?|\\[^\n\r\f0-9A-Fa-f])*/))
+                  when (text = @ss.scan(/-?([_A-Za-z]|[^\0-\177]|\\[0-9A-Fa-f]{1,6}(\r\n|[\s])?|\\[^\n\r\f0-9A-Fa-f])([_A-Za-z0-9-]|[^\0-\177]|\\[0-9A-Fa-f]{1,6}(\r\n|[\s])?|\\[^\n\r\f0-9A-Fa-f])*/))
                      action { [:IDENT, text] }
 
                   when (text = @ss.scan(/\#([_A-Za-z0-9-]|[^\0-\177]|\\[0-9A-Fa-f]{1,6}(\r\n|[\s])?|\\[^\n\r\f0-9A-Fa-f])+/))

data/lib/nokogiri/css/tokenizer.rex

@@ -1,6 +1,7 @@
 module Nokogiri
 module CSS
-class Tokenizer # :nodoc:
+# :nodoc: all
+class Tokenizer
 
 macro
   nl        \n|\r\n|\r|\f
@@ -12,7 +13,7 @@ macro
   escape    {unicode}|\\[^\n\r\f0-9A-Fa-f]
   nmchar    [_A-Za-z0-9-]|{nonascii}|{escape}
   nmstart   [_A-Za-z]|{nonascii}|{escape}
-  ident     [-@]?({nmstart})({nmchar})*
+  ident     -?({nmstart})({nmchar})*
   name      ({nmchar})+
   string1   "([^\n\r\f"]|{nl}|{nonascii}|{escape})*(?<!\\)(?:\\{2})*"
   string2   '([^\n\r\f']|{nl}|{nonascii}|{escape})*(?<!\\)(?:\\{2})*'