nokogiri 1.11.0.rc4-arm64-darwin

data/lib/nokogiri/css/parser.y

@@ -0,0 +1,272 @@
+class Nokogiri::CSS::Parser
+
+token FUNCTION INCLUDES DASHMATCH LBRACE HASH PLUS GREATER S STRING IDENT
+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
+    |
+    ;
+end
+
+---- header
+
+require 'nokogiri/css/parser_extras'
+
+---- inner
+
+def unescape_css_identifier(identifier)
+  identifier.gsub(/\\(?:([^0-9a-fA-F])|([0-9a-fA-F]{1,6})\s?)/){ |m| $1 || [$2.hex].pack('U') }
+end
+
+def unescape_css_string(str)
+  str.gsub(/\\(?:([^0-9a-fA-F])|([0-9a-fA-F]{1,6})\s?)/) do |m|
+    if $1=="\n"
+      ''
+    else
+      $1 || [$2.hex].pack('U')
+    end
+  end
+end

data/lib/nokogiri/css/parser_extras.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+require "thread"
+
+module Nokogiri
+  module CSS
+    class Parser < Racc::Parser
+      CACHE_SWITCH_NAME = :nokogiri_css_parser_cache_is_off
+
+      @cache = {}
+      @mutex = Mutex.new
+
+      class << self
+        # 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?
+          @mutex.synchronize { @cache[string] }
+        end
+
+        # Set the css selector in +string+ in the cache to +value+
+        def []=(string, value)
+          return value unless cache_on?
+          @mutex.synchronize { @cache[string] = value }
+        end
+
+        # Clear the 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)
+          original_cache_setting = cache_on?
+          set_cache false
+          block.call
+        ensure
+          set_cache original_cache_setting
+        end
+      end
+
+      # Create a new CSS parser with respect to +namespaces+
+      def initialize(namespaces = {})
+        @tokenizer = Tokenizer.new
+        @namespaces = namespaces
+        super()
+      end
+
+      def parse(string)
+        @tokenizer.scan_setup string
+        do_parse
+      end
+
+      def next_token
+        @tokenizer.next_token
+      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)
+        }
+      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}'")
+      end
+    end
+  end
+end

data/lib/nokogiri/css/syntax_error.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+require 'nokogiri/syntax_error'
+module Nokogiri
+  module CSS
+    class SyntaxError < ::Nokogiri::SyntaxError
+    end
+  end
+end

data/lib/nokogiri/css/tokenizer.rb

@@ -0,0 +1,154 @@
+# frozen_string_literal: true
+#--
+# DO NOT MODIFY!!!!
+# 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'
+
+      class ScanError < StandardError ; end
+
+      attr_reader   :lineno
+      attr_reader   :filename
+      attr_accessor :state
+
+      def scan_setup(str)
+        @ss = StringScanner.new(str)
+        @lineno =  1
+        @state  = nil
+      end
+
+      def action
+        yield
+      end
+
+      def scan_str(str)
+        scan_setup(str)
+        do_parse
+      end
+      alias :scan :scan_str
+
+      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 next_token
+          return if @ss.eos?
+
+          # skips empty actions
+          until token = _next_token or @ss.eos?; end
+          token
+        end
+
+        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])*\([\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])*/))
+                     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])+/))
+                     action { [:HASH, text] }
+
+                  when (text = @ss.scan(/[\s]*~=[\s]*/))
+                     action { [:INCLUDES, text] }
+
+                  when (text = @ss.scan(/[\s]*\|=[\s]*/))
+                     action { [:DASHMATCH, text] }
+
+                  when (text = @ss.scan(/[\s]*\^=[\s]*/))
+                     action { [:PREFIXMATCH, text] }
+
+                  when (text = @ss.scan(/[\s]*\$=[\s]*/))
+                     action { [:SUFFIXMATCH, text] }
+
+                  when (text = @ss.scan(/[\s]*\*=[\s]*/))
+                     action { [:SUBSTRINGMATCH, text] }
+
+                  when (text = @ss.scan(/[\s]*!=[\s]*/))
+                     action { [:NOT_EQUAL, text] }
+
+                  when (text = @ss.scan(/[\s]*=[\s]*/))
+                     action { [:EQUAL, text] }
+
+                  when (text = @ss.scan(/[\s]*\)/))
+                     action { [:RPAREN, text] }
+
+                  when (text = @ss.scan(/\[[\s]*/))
+                     action { [:LSQUARE, text] }
+
+                  when (text = @ss.scan(/[\s]*\]/))
+                     action { [:RSQUARE, text] }
+
+                  when (text = @ss.scan(/[\s]*\+[\s]*/))
+                     action { [:PLUS, text] }
+
+                  when (text = @ss.scan(/[\s]*>[\s]*/))
+                     action { [:GREATER, text] }
+
+                  when (text = @ss.scan(/[\s]*,[\s]*/))
+                     action { [:COMMA, text] }
+
+                  when (text = @ss.scan(/[\s]*~[\s]*/))
+                     action { [:TILDE, text] }
+
+                  when (text = @ss.scan(/\:not\([\s]*/))
+                     action { [:NOT, text] }
+
+                  when (text = @ss.scan(/-?([0-9]+|[0-9]*\.[0-9]+)/))
+                     action { [:NUMBER, text] }
+
+                  when (text = @ss.scan(/[\s]*\/\/[\s]*/))
+                     action { [:DOUBLESLASH, text] }
+
+                  when (text = @ss.scan(/[\s]*\/[\s]*/))
+                     action { [:SLASH, 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]+/))
+                     action { [:S, 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(/./))
+                     action { [text, text] }
+
+          
+          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
+end