nokogiri 1.18.0.rc1-aarch64-linux-gnu

data/lib/nokogiri/css/parser.y

@@ -0,0 +1,277 @@
+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[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]]) }
+  | IDENT {
+      name = 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)
+  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,36 @@
+# frozen_string_literal: true
+
+require "thread"
+
+module Nokogiri
+  module CSS
+    class Parser < Racc::Parser # :nodoc:
+      def initialize
+        @tokenizer = Tokenizer.new
+        super
+      end
+
+      def parse(string)
+        @tokenizer.scan_setup(string)
+        do_parse
+      end
+
+      def next_token
+        @tokenizer.next_token
+      end
+
+      # Get the xpath for +selector+ using +visitor+
+      def xpath_for(selector, visitor)
+        parse(selector).map do |ast|
+          ast.to_xpath(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, "unexpected '#{error_value}' after '#{after}'"
+      end
+    end
+  end
+end

data/lib/nokogiri/css/selector_cache.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Nokogiri
+  module CSS
+    module SelectorCache # :nodoc:
+      @cache = {}
+      @mutex = Mutex.new
+
+      class << self
+        # Retrieve the cached XPath expressions for the key
+        def [](key)
+          @mutex.synchronize { @cache[key] }
+        end
+
+        # Insert the XPath expressions `value` at the cache key
+        def []=(key, value)
+          @mutex.synchronize { @cache[key] = value }
+        end
+
+        # Clear the cache
+        def clear_cache(create_new_object = false)
+          @mutex.synchronize do
+            if create_new_object # used in tests to avoid 'method redefined' warnings when injecting spies
+              @cache = {}
+            else
+              @cache.clear
+            end
+          end
+        end
+
+        # Construct a unique key cache key
+        def key(selector:, visitor:)
+          [selector, visitor.config]
+        end
+      end
+    end
+  end
+end

data/lib/nokogiri/css/syntax_error.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require_relative "../syntax_error"
+module Nokogiri
+  module CSS
+    class SyntaxError < ::Nokogiri::SyntaxError
+    end
+  end
+end

data/lib/nokogiri/css/tokenizer.rb

@@ -0,0 +1,155 @@
+# 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
+# :nodoc: all
+class Tokenizer
+      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

data/lib/nokogiri/css/tokenizer.rex

@@ -0,0 +1,57 @@
+module Nokogiri
+module CSS
+# :nodoc: all
+class Tokenizer
+
+macro
+  nl        (\n|\r\n|\r|\f)
+  w         [\s]*
+  nonascii  [^\0-\177]
+  num       -?([0-9]+|[0-9]*\.[0-9]+)
+  unicode   \\[0-9A-Fa-f]{1,6}(\r\n|[\s])?
+
+  escape    ({unicode}|\\[^\n\r\f0-9A-Fa-f])
+  nmchar    ([_A-Za-z0-9-]|{nonascii}|{escape})
+  nmstart   ([_A-Za-z]|{nonascii}|{escape})
+  name      {nmstart}{nmchar}*
+  ident     -?{name}
+  charref   {nmchar}+
+  string1   "([^\n\r\f"]|{nl}|{nonascii}|{escape})*(?<!\\)(?:\\{2})*"
+  string2   '([^\n\r\f']|{nl}|{nonascii}|{escape})*(?<!\\)(?:\\{2})*'
+  string    ({string1}|{string2})
+
+rule
+
+# [:state]  pattern  [actions]
+
+            has\({w}         { [:HAS, text] }
+            {ident}\({w}     { [:FUNCTION, text] }
+            {ident}          { [:IDENT, text] }
+            \#{charref}      { [:HASH, text] }
+            {w}~={w}         { [:INCLUDES, text] }
+            {w}\|={w}        { [:DASHMATCH, text] }
+            {w}\^={w}        { [:PREFIXMATCH, text] }
+            {w}\$={w}        { [:SUFFIXMATCH, text] }
+            {w}\*={w}        { [:SUBSTRINGMATCH, text] }
+            {w}!={w}         { [:NOT_EQUAL, text] }
+            {w}={w}          { [:EQUAL, text] }
+            {w}\)            { [:RPAREN, text] }
+            \[{w}            { [:LSQUARE, text] }
+            {w}\]            { [:RSQUARE, text] }
+            {w}\+{w}         { [:PLUS, text] }
+            {w}>{w}          { [:GREATER, text] }
+            {w},{w}          { [:COMMA, text] }
+            {w}~{w}          { [:TILDE, text] }
+            \:not\({w}       { [:NOT, text] }
+            {num}            { [:NUMBER, text] }
+            {w}\/\/{w}       { [:DOUBLESLASH, text] }
+            {w}\/{w}         { [:SLASH, text] }
+
+            U\+[0-9a-f?]{1,6}(-[0-9a-f]{1,6})?  {[:UNICODE_RANGE, text] }
+
+            [\s]+            { [:S, text] }
+            {string}         { [:STRING, text] }
+            .                { [text, text] }
+end
+end
+end