nokogiri 1.10.0 → 1.11.1

data/lib/nokogiri/css/parser.y

@@ -88,7 +88,7 @@ rule
         )
       }
     | LSQUARE NUMBER RSQUARE {
-        # Non standard, but hpricot supports it.
+        # non-standard, from hpricot
         result = Node.new(:PSEUDO_CLASS,
           [Node.new(:FUNCTION, ['nth-child(', val[1]])]
         )
@@ -139,7 +139,7 @@ rule
         when 'n'
           result = Node.new(:NTH, ['1','n','+','0'])
         else
-          # This is not CSS standard.  It allows us to support this:
+          # 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)'))

data/lib/nokogiri/css/parser_extras.rb

@@ -1,63 +1,66 @@
-require 'thread'
+# frozen_string_literal: true
+require "thread"
 
 module Nokogiri
   module CSS
     class Parser < Racc::Parser
-      @cache_on = true
-      @cache    = {}
-      @mutex    = Mutex.new
+      CACHE_SWITCH_NAME = :nokogiri_css_parser_cache_is_off
+
+      @cache = {}
+      @mutex = Mutex.new
 
       class << self
-        # Turn on CSS parse caching
-        attr_accessor :cache_on
-        alias :cache_on? :cache_on
-        alias :set_cache :cache_on=
+        # Return a thread-local boolean indicating whether the CSS-to-XPath cache is active. (Default is `true`.)
+        def cache_on?
+          !Thread.current[CACHE_SWITCH_NAME]
+        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)
+          Thread.current[CACHE_SWITCH_NAME] = !value
+        end
 
         # Get the css selector in +string+ from the cache
-        def [] string
-          return unless @cache_on
+        def [](string)
+          return unless cache_on?
           @mutex.synchronize { @cache[string] }
         end
 
         # Set the css selector in +string+ in the cache to +value+
-        def []= string, value
-          return value unless @cache_on
+        def []=(string, value)
+          return value unless cache_on?
           @mutex.synchronize { @cache[string] = value }
         end
 
         # Clear the cache
-        def clear_cache
-          @mutex.synchronize { @cache = {} }
+        def clear_cache(create_new_object = false)
+          @mutex.synchronize do
+            if create_new_object
+              @cache = {}
+            else
+              @cache.clear
+            end
+          end
         end
 
         # Execute +block+ without cache
-        def without_cache &block
-          tmp = @cache_on
-          @cache_on = false
+        def without_cache(&block)
+          original_cache_setting = cache_on?
+          set_cache false
           block.call
-          @cache_on = tmp
-        end
-
-        ###
-        # Parse this CSS selector in +selector+.  Returns an AST.
-        def parse selector
-          @warned ||= false
-          unless @warned
-            $stderr.puts('Nokogiri::CSS::Parser.parse is deprecated, call Nokogiri::CSS.parse(), this will be removed August 1st or version 1.4.0 (whichever is first)')
-            @warned = true
-          end
-          new.parse selector
+        ensure
+          set_cache original_cache_setting
         end
       end
 
       # Create a new CSS parser with respect to +namespaces+
-      def initialize namespaces = {}
-        @tokenizer  = Tokenizer.new
+      def initialize(namespaces = {})
+        @tokenizer = Tokenizer.new
         @namespaces = namespaces
         super()
       end
 
-      def parse string
+      def parse(string)
         @tokenizer.scan_setup string
         do_parse
       end
@@ -67,14 +70,14 @@ module Nokogiri
       end
 
       # Get the xpath for +string+ using +options+
-      def xpath_for string, 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
+          options[:prefix] || "//",
+          options[:visitor] || XPathVisitor.new,
         ]
         self.class[key] = parse(string).map { |ast|
           ast.to_xpath(*args)
@@ -82,7 +85,7 @@ module Nokogiri
       end
 
       # On CSS parser error, raise an exception
-      def on_error error_token_id, error_value, value_stack
+      def on_error(error_token_id, error_value, value_stack)
         after = value_stack.compact.last
         raise SyntaxError.new("unexpected '#{error_value}' after '#{after}'")
       end

data/lib/nokogiri/css/syntax_error.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'nokogiri/syntax_error'
 module Nokogiri
   module CSS

data/lib/nokogiri/css/tokenizer.rb

@@ -1,151 +1,153 @@
+# frozen_string_literal: true
 #--
 # DO NOT MODIFY!!!!
-# This file is automatically generated by rex 1.0.5
+# This file is automatically generated by rex 1.0.7
 # from lexical definition file "lib/nokogiri/css/tokenizer.rex".
 #++
 
 module Nokogiri
 module CSS
 class Tokenizer # :nodoc:
-  require 'strscan'
+      require 'strscan'
 
-  class ScanError < StandardError ; end
+      class ScanError < StandardError ; end
 
-  attr_reader   :lineno
-  attr_reader   :filename
-  attr_accessor :state
+      attr_reader   :lineno
+      attr_reader   :filename
+      attr_accessor :state
 
-  def scan_setup(str)
-    @ss = StringScanner.new(str)
-    @lineno =  1
-    @state  = nil
-  end
+      def scan_setup(str)
+        @ss = StringScanner.new(str)
+        @lineno =  1
+        @state  = nil
+      end
 
-  def action
-    yield
-  end
+      def action
+        yield
+      end
 
-  def scan_str(str)
-    scan_setup(str)
-    do_parse
-  end
-  alias :scan :scan_str
+      def scan_str(str)
+        scan_setup(str)
+        do_parse
+      end
+      alias :scan :scan_str
 
-  def load_file( filename )
-    @filename = filename
-    open(filename, "r") do |f|
-      scan_setup(f.read)
-    end
-  end
+      def load_file( filename )
+        @filename = filename
+        File.open(filename, "r") do |f|
+          scan_setup(f.read)
+        end
+      end
 
-  def scan_file( filename )
-    load_file(filename)
-    do_parse
-  end
+      def scan_file( filename )
+        load_file(filename)
+        do_parse
+      end
 
 
-  def next_token
-    return if @ss.eos?
-    
-    # skips empty actions
-    until token = _next_token or @ss.eos?; end
-    token
-  end
+        def next_token
+          return if @ss.eos?
 
-  def _next_token
-    text = @ss.peek(1)
-    @lineno  +=  1  if text == "\n"
-    token = case @state
-    when nil
-      case
-      when (text = @ss.scan(/has\([\s]*/))
-         action { [:HAS, text] }
+          # skips empty actions
+          until token = _next_token or @ss.eos?; end
+          token
+        end
 
-      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] }
+        def _next_token
+          text = @ss.peek(1)
+          @lineno  +=  1  if text == "\n"
+          token = case @state
+            when nil
+          case
+                  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])*/))
-         action { [:IDENT, 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]*/))
+                     action { [:FUNCTION, 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])+/))
-         action { [:HASH, 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])*/))
+                     action { [:IDENT, text] }
 
-      when (text = @ss.scan(/[\s]*~=[\s]*/))
-         action { [:INCLUDES, 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])+/))
+                     action { [:HASH, text] }
 
-      when (text = @ss.scan(/[\s]*\|=[\s]*/))
-         action { [:DASHMATCH, text] }
+                  when (text = @ss.scan(/[\s]*~=[\s]*/))
+                     action { [:INCLUDES, text] }
 
-      when (text = @ss.scan(/[\s]*\^=[\s]*/))
-         action { [:PREFIXMATCH, text] }
+                  when (text = @ss.scan(/[\s]*\|=[\s]*/))
+                     action { [:DASHMATCH, text] }
 
-      when (text = @ss.scan(/[\s]*\$=[\s]*/))
-         action { [:SUFFIXMATCH, text] }
+                  when (text = @ss.scan(/[\s]*\^=[\s]*/))
+                     action { [:PREFIXMATCH, text] }
 
-      when (text = @ss.scan(/[\s]*\*=[\s]*/))
-         action { [:SUBSTRINGMATCH, text] }
+                  when (text = @ss.scan(/[\s]*\$=[\s]*/))
+                     action { [:SUFFIXMATCH, text] }
 
-      when (text = @ss.scan(/[\s]*!=[\s]*/))
-         action { [:NOT_EQUAL, text] }
+                  when (text = @ss.scan(/[\s]*\*=[\s]*/))
+                     action { [:SUBSTRINGMATCH, text] }
 
-      when (text = @ss.scan(/[\s]*=[\s]*/))
-         action { [:EQUAL, text] }
+                  when (text = @ss.scan(/[\s]*!=[\s]*/))
+                     action { [:NOT_EQUAL, text] }
 
-      when (text = @ss.scan(/[\s]*\)/))
-         action { [:RPAREN, text] }
+                  when (text = @ss.scan(/[\s]*=[\s]*/))
+                     action { [:EQUAL, text] }
 
-      when (text = @ss.scan(/\[[\s]*/))
-         action { [:LSQUARE, text] }
+                  when (text = @ss.scan(/[\s]*\)/))
+                     action { [:RPAREN, text] }
 
-      when (text = @ss.scan(/[\s]*\]/))
-         action { [:RSQUARE, text] }
+                  when (text = @ss.scan(/\[[\s]*/))
+                     action { [:LSQUARE, text] }
 
-      when (text = @ss.scan(/[\s]*\+[\s]*/))
-         action { [:PLUS, text] }
+                  when (text = @ss.scan(/[\s]*\]/))
+                     action { [:RSQUARE, text] }
 
-      when (text = @ss.scan(/[\s]*>[\s]*/))
-         action { [:GREATER, text] }
+                  when (text = @ss.scan(/[\s]*\+[\s]*/))
+                     action { [:PLUS, text] }
 
-      when (text = @ss.scan(/[\s]*,[\s]*/))
-         action { [:COMMA, text] }
+                  when (text = @ss.scan(/[\s]*>[\s]*/))
+                     action { [:GREATER, text] }
 
-      when (text = @ss.scan(/[\s]*~[\s]*/))
-         action { [:TILDE, text] }
+                  when (text = @ss.scan(/[\s]*,[\s]*/))
+                     action { [:COMMA, text] }
 
-      when (text = @ss.scan(/\:not\([\s]*/))
-         action { [:NOT, text] }
+                  when (text = @ss.scan(/[\s]*~[\s]*/))
+                     action { [:TILDE, text] }
 
-      when (text = @ss.scan(/-?([0-9]+|[0-9]*\.[0-9]+)/))
-         action { [:NUMBER, text] }
+                  when (text = @ss.scan(/\:not\([\s]*/))
+                     action { [:NOT, text] }
 
-      when (text = @ss.scan(/[\s]*\/\/[\s]*/))
-         action { [:DOUBLESLASH, text] }
+                  when (text = @ss.scan(/-?([0-9]+|[0-9]*\.[0-9]+)/))
+                     action { [:NUMBER, text] }
 
-      when (text = @ss.scan(/[\s]*\/[\s]*/))
-         action { [:SLASH, text] }
+                  when (text = @ss.scan(/[\s]*\/\/[\s]*/))
+                     action { [:DOUBLESLASH, text] }
 
-      when (text = @ss.scan(/U\+[0-9a-f?]{1,6}(-[0-9a-f]{1,6})?/))
-         action {[:UNICODE_RANGE, text] }
+                  when (text = @ss.scan(/[\s]*\/[\s]*/))
+                     action { [:SLASH, text] }
 
-      when (text = @ss.scan(/[\s]+/))
-         action { [:S, text] }
+                  when (text = @ss.scan(/U\+[0-9a-f?]{1,6}(-[0-9a-f]{1,6})?/))
+                     action {[:UNICODE_RANGE, text] }
 
-      when (text = @ss.scan(/"([^\n\r\f"]|\n|\r\n|\r|\f|[^\0-\177]|\\[0-9A-Fa-f]{1,6}(\r\n|[\s])?|\\[^\n\r\f0-9A-Fa-f])*(?<!\\)(?:\\{2})*"|'([^\n\r\f']|\n|\r\n|\r|\f|[^\0-\177]|\\[0-9A-Fa-f]{1,6}(\r\n|[\s])?|\\[^\n\r\f0-9A-Fa-f])*(?<!\\)(?:\\{2})*'/))
-         action { [:STRING, text] }
+                  when (text = @ss.scan(/[\s]+/))
+                     action { [:S, text] }
 
-      when (text = @ss.scan(/./))
-         action { [text, text] }
+                  when (text = @ss.scan(/"([^\n\r\f"]|\n|\r\n|\r|\f|[^\0-\177]|\\[0-9A-Fa-f]{1,6}(\r\n|[\s])?|\\[^\n\r\f0-9A-Fa-f])*(?<!\\)(?:\\{2})*"|'([^\n\r\f']|\n|\r\n|\r|\f|[^\0-\177]|\\[0-9A-Fa-f]{1,6}(\r\n|[\s])?|\\[^\n\r\f0-9A-Fa-f])*(?<!\\)(?:\\{2})*'/))
+                     action { [:STRING, text] }
 
-      else
-        text = @ss.string[@ss.pos .. -1]
-        raise  ScanError, "can not match: '" + text + "'"
-      end  # if
+                  when (text = @ss.scan(/./))
+                     action { [text, text] }
 
-    else
-      raise  ScanError, "undefined state: '" + state.to_s + "'"
-    end  # case state
-    token
-  end  # def _next_token
+          
+          else
+            text = @ss.string[@ss.pos .. -1]
+            raise  ScanError, "can not match: '" + text + "'"
+          end  # if
+
+        else
+          raise  ScanError, "undefined state: '" + state.to_s + "'"
+        end  # case state
+          token
+        end  # def _next_token
 
 end # class
 end

data/lib/nokogiri/css/xpath_visitor.rb

@@ -1,8 +1,8 @@
+# frozen_string_literal: true
 module Nokogiri
   module CSS
     class XPathVisitor # :nodoc:
       def visit_function node
-
         msg = :"visit_function_#{node.value.first.gsub(/[(]/, '')}"
         return self.send(msg, node) if self.respond_to?(msg)
 
@@ -12,49 +12,51 @@ module Nokogiri
         when /^self\(/
           "self::#{node.value[1]}"
         when /^eq\(/
-          "position() = #{node.value[1]}"
+          "position()=#{node.value[1]}"
         when /^(nth|nth-of-type)\(/
           if node.value[1].is_a?(Nokogiri::CSS::Node) and node.value[1].type == :NTH
             nth(node.value[1])
           else
-            "position() = #{node.value[1]}"
+            "position()=#{node.value[1]}"
           end
         when /^nth-child\(/
           if node.value[1].is_a?(Nokogiri::CSS::Node) and node.value[1].type == :NTH
             nth(node.value[1], :child => true)
           else
-            "count(preceding-sibling::*) = #{node.value[1].to_i-1}"
+            "count(preceding-sibling::*)=#{node.value[1].to_i-1}"
           end
         when /^nth-last-of-type\(/
           if node.value[1].is_a?(Nokogiri::CSS::Node) and node.value[1].type == :NTH
             nth(node.value[1], :last => true)
           else
             index = node.value[1].to_i - 1
-            index == 0 ? "position() = last()" : "position() = last() - #{index}"
+            index == 0 ? "position()=last()" : "position()=last()-#{index}"
           end
         when /^nth-last-child\(/
           if node.value[1].is_a?(Nokogiri::CSS::Node) and node.value[1].type == :NTH
             nth(node.value[1], :last => true, :child => true)
           else
-            "count(following-sibling::*) = #{node.value[1].to_i-1}"
+            "count(following-sibling::*)=#{node.value[1].to_i-1}"
           end
         when /^(first|first-of-type)\(/
-          "position() = 1"
+          "position()=1"
         when /^(last|last-of-type)\(/
-          "position() = last()"
+          "position()=last()"
         when /^contains\(/
-          "contains(., #{node.value[1]})"
+          "contains(.,#{node.value[1]})"
         when /^gt\(/
-          "position() > #{node.value[1]}"
+          "position()>#{node.value[1]}"
         when /^only-child\(/
-          "last() = 1"
+          "last()=1"
         when /^comment\(/
           "comment()"
         when /^has\(/
-          node.value[1].accept(self)
+          is_direct = node.value[1].value[0].nil? # e.g. "has(> a)", "has(~ a)", "has(+ a)"
+          ".#{"//" if !is_direct}#{node.value[1].accept(self)}"
         else
+          # non-standard. this looks like a function call.
           args = ['.'] + node.value[1..-1]
-          "#{node.value.first}#{args.join(', ')})"
+          "#{node.value.first}#{args.join(',')})"
         end
       end
 
@@ -69,18 +71,18 @@ module Nokogiri
 
       def visit_id node
         node.value.first =~ /^#(.*)$/
-        "@id = '#{$1}'"
+        "@id='#{$1}'"
       end
 
       def visit_attribute_condition node
-         attribute = if (node.value.first.type == :FUNCTION) or (node.value.first.value.first =~ /::/)
-                       ''
-                     else
-                       '@'
-                     end
+        attribute = if (node.value.first.type == :FUNCTION) or (node.value.first.value.first =~ /::/)
+                      ''
+                    else
+                      '@'
+                    end
         attribute += node.value.first.accept(self)
 
-        # Support non-standard css
+        # non-standard. attributes starting with '@'
         attribute.gsub!(/^@@/, '@')
 
         return attribute unless node.value.length == 3
@@ -88,29 +90,30 @@ module Nokogiri
         value = node.value.last
         value = "'#{value}'" if value !~ /^['"]/
 
+        # quoted values - see test_attribute_value_with_quotes in test/css/test_parser.rb
         if (value[0]==value[-1]) && %q{"'}.include?(value[0])
           str_value = value[1..-2]
           if str_value.include?(value[0])
-            value = 'concat("' + str_value.split('"', -1).join(%q{", '"', "}) + '", "")'
+            value = 'concat("' + str_value.split('"', -1).join(%q{",'"',"}) + '","")'
           end
         end
 
         case node.value[1]
         when :equal
-          attribute + " = " + "#{value}"
+          attribute + "=" + "#{value}"
         when :not_equal
-          attribute + " != " + "#{value}"
+          attribute + "!=" + "#{value}"
         when :substring_match
-          "contains(#{attribute}, #{value})"
+          "contains(#{attribute},#{value})"
         when :prefix_match
-          "starts-with(#{attribute}, #{value})"
+          "starts-with(#{attribute},#{value})"
         when :dash_match
-          "#{attribute} = #{value} or starts-with(#{attribute}, concat(#{value}, '-'))"
+          "#{attribute}=#{value} or starts-with(#{attribute},concat(#{value},'-'))"
         when :includes
-          "contains(concat(\" \", #{attribute}, \" \"),concat(\" \", #{value}, \" \"))"
+          value = value[1..-2] # strip quotes
+          css_class(attribute, value)
         when :suffix_match
-          "substring(#{attribute}, string-length(#{attribute}) - " +
-            "string-length(#{value}) + 1, string-length(#{value})) = #{value}"
+          "substring(#{attribute},string-length(#{attribute})-string-length(#{value})+1,string-length(#{value}))=#{value}"
         else
           attribute + " #{node.value[1]} " + "#{value}"
         end
@@ -124,14 +127,14 @@ module Nokogiri
           return self.send(msg, node) if self.respond_to?(msg)
 
           case node.value.first
-          when "first" then "position() = 1"
-          when "first-child" then "count(preceding-sibling::*) = 0"
-          when "last" then "position() = last()"
-          when "last-child" then "count(following-sibling::*) = 0"
-          when "first-of-type" then "position() = 1"
-          when "last-of-type" then "position() = last()"
-          when "only-child" then "count(preceding-sibling::*) = 0 and count(following-sibling::*) = 0"
-          when "only-of-type" then "last() = 1"
+          when "first" then "position()=1"
+          when "first-child" then "count(preceding-sibling::*)=0"
+          when "last" then "position()=last()"
+          when "last-child" then "count(following-sibling::*)=0"
+          when "first-of-type" then "position()=1"
+          when "last-of-type" then "position()=last()"
+          when "only-child" then "count(preceding-sibling::*)=0 and count(following-sibling::*)=0"
+          when "only-of-type" then "last()=1"
           when "empty" then "not(node())"
           when "parent" then "node()"
           when "root" then "not(parent::*)"
@@ -142,7 +145,7 @@ module Nokogiri
       end
 
       def visit_class_condition node
-        "contains(concat(' ', normalize-space(@class), ' '), ' #{node.value.first} ')"
+        css_class("@class", node.value.first)
       end
 
       def visit_combinator node
@@ -179,25 +182,26 @@ module Nokogiri
         node.accept(self)
       end
 
-    private
+      private
+
       def nth node, options={}
         raise ArgumentError, "expected an+b node to contain 4 tokens, but is #{node.value.inspect}" unless node.value.size == 4
 
         a, b = read_a_and_positive_b node.value
         position = if options[:child]
-          options[:last] ? "(count(following-sibling::*) + 1)" : "(count(preceding-sibling::*) + 1)"
+          options[:last] ? "(count(following-sibling::*)+1)" : "(count(preceding-sibling::*)+1)"
         else
           options[:last] ? "(last()-position()+1)" : "position()"
         end
 
         if b.zero?
-          "(#{position} mod #{a}) = 0"
+          "(#{position} mod #{a})=0"
         else
           compare = a < 0 ? "<=" : ">="
           if a.abs == 1
-            "#{position} #{compare} #{b}"
+            "#{position}#{compare}#{b}"
           else
-            "(#{position} #{compare} #{b}) and (((#{position}-#{b}) mod #{a.abs}) = 0)"
+            "(#{position}#{compare}#{b}) and (((#{position}-#{b}) mod #{a.abs})=0)"
           end
         end
       end
@@ -225,6 +229,32 @@ module Nokogiri
           end =~ /(nth|first|last|only)-of-type(\()?/
         end
       end
+
+      # use only ordinary xpath functions
+      def css_class_standard(hay, needle)
+        "contains(concat(' ',normalize-space(#{hay}),' '),' #{needle} ')"
+      end
+
+      # use the builtin implementation
+      def css_class_builtin(hay, needle)
+        "nokogiri-builtin:css-class(#{hay},'#{needle}')"
+      end
+
+      alias_method :css_class, :css_class_standard
+    end
+
+    class XPathVisitorAlwaysUseBuiltins < XPathVisitor # :nodoc:
+      private
+      alias_method :css_class, :css_class_builtin
+    end
+
+    class XPathVisitorOptimallyUseBuiltins < XPathVisitor # :nodoc:
+      private
+      if Nokogiri.uses_libxml?
+        alias_method :css_class, :css_class_builtin
+      else
+        alias_method :css_class, :css_class_standard
+      end
     end
   end
 end