nokogiri 1.2.3-x86-mswin32-60 → 1.4.5-x86-mswin32-60

data/lib/nokogiri/css/parser.y

@@ -1,8 +1,8 @@
-class Nokogiri::CSS::GeneratedParser
+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
+token SLASH DOUBLESLASH NOT EQUAL RPAREN LSQUARE RSQUARE HAS
 
 rule
   selector
@@ -39,6 +39,9 @@ rule
         result = Node.new(:CONDITIONAL_SELECTOR, val)
       }
     | function
+    | function pseudo {
+        result = Node.new(:CONDITIONAL_SELECTOR, val)
+      }
     | function attrib {
         result = Node.new(:CONDITIONAL_SELECTOR, val)
       }
@@ -112,6 +115,9 @@ rule
     | 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] }
@@ -205,13 +211,13 @@ rule
     |
     ;
   eql_incl_dash
-    : EQUAL
-    | PREFIXMATCH
-    | SUFFIXMATCH
-    | SUBSTRINGMATCH
-    | NOT_EQUAL
-    | INCLUDES
-    | DASHMATCH
+    : 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 {
@@ -219,9 +225,13 @@ rule
       }
     ;
   negation_arg
-    : hcap_1toN
+    : element_name
+    | element_name hcap_1toN
+    | hcap_1toN
     ;
 end
 
 ---- header
 
+require 'nokogiri/css/parser_extras'
+

data/lib/nokogiri/css/parser_extras.rb

@@ -0,0 +1,91 @@
+require 'thread'
+
+module Nokogiri
+  module CSS
+    class Parser < Racc::Parser
+      @cache_on = true
+      @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=
+
+        # 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
+          @mutex.synchronize { @cache = {} }
+        end
+
+        # Execute +block+ without cache
+        def without_cache &block
+          tmp = @cache_on
+          @cache_on = 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
+        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/tokenizer.rb

@@ -1,9 +1,152 @@
+#--
+# DO NOT MODIFY!!!!
+# This file is automatically generated by rex 1.0.5
+# from lexical definition file "lib/nokogiri/css/tokenizer.rex".
+#++
+
 module Nokogiri
-  module CSS
-    class Tokenizer < GeneratedTokenizer
-      def scan(str)
-        scan_evaluate(str)
-      end
+module CSS
+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
+    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]*\[[\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])*"|'([^\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])*'/))
+         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

@@ -1,28 +1,29 @@
 module Nokogiri
 module CSS
-class GeneratedTokenizer < GeneratedParser
+class Tokenizer
 
 macro
   nl        \n|\r\n|\r|\f
-  w         [\s\r\n\f]*
-  nonascii  [^\\\\0-\\\\177]
+  w         [\s]*
+  nonascii  [^\0-\177]
   num       -?([0-9]+|[0-9]*\.[0-9]+)
-  unicode   \\\\\\\\\[0-9A-Fa-f]{1,6}(\r\n|[\s\n\r\t\f])?
+  unicode   \\[0-9A-Fa-f]{1,6}(\r\n|[\s])?
 
-  escape    {unicode}|\\\\\\\[^\n\r\f0-9A-Fa-f]
+  escape    {unicode}|\\[^\n\r\f0-9A-Fa-f]
   nmchar    [_A-Za-z0-9-]|{nonascii}|{escape}
   nmstart   [_A-Za-z]|{nonascii}|{escape}
   ident     [-@]?({nmstart})({nmchar})*
   name      ({nmchar})+
-  string1   "([^\n\r\f"]|\\{nl}|{nonascii}|{escape})*"
-  string2   '([^\n\r\f']|\\{nl}|{nonascii}|{escape})*'
+  string1   "([^\n\r\f"]|{nl}|{nonascii}|{escape})*"
+  string2   '([^\n\r\f']|{nl}|{nonascii}|{escape})*'
   string    {string1}|{string2}
 
 rule
 
 # [:state]  pattern  [actions]
 
-            {ident}\(\s*     { [:FUNCTION, text] }
+            has\({w}         { [:HAS, text] }
+            {ident}\({w}     { [:FUNCTION, text] }
             {ident}          { [:IDENT, text] }
             \#{name}         { [:HASH, text] }
             {w}~={w}         { [:INCLUDES, text] }
@@ -46,7 +47,7 @@ rule
             
             U\+[0-9a-f?]{1,6}(-[0-9a-f]{1,6})?  {[:UNICODE_RANGE, text] }
             
-            [\s\t\r\n\f]+    { [:S, text] }
+            [\s]+            { [:S, text] }
             {string}         { [:STRING, text] }
             .                { [text, text] }
 end

data/lib/nokogiri/css/xpath_visitor.rb

@@ -1,6 +1,6 @@
 module Nokogiri
   module CSS
-    class XPathVisitor
+    class XPathVisitor # :nodoc:
       def visit_function node
         #  note that nth-child and nth-last-child are preprocessed in css/node.rb.
         msg = :"visit_function_#{node.value.first.gsub(/[(]/, '')}"
@@ -11,18 +11,25 @@ module Nokogiri
           'child::text()'
         when /^self\(/
           "self::#{node.value[1]}"
-        when /^(eq|nth|nth-of-type|nth-child)\(/
+        when /^eq\(/
+          "position() = #{node.value[1]}"
+        when /^(nth|nth-of-type|nth-child)\(/
           if node.value[1].is_a?(Nokogiri::CSS::Node) and node.value[1].type == :AN_PLUS_B
             an_plus_b(node.value[1])
           else
-            "position() = " + node.value[1]
+            "position() = #{node.value[1]}"
+          end
+        when /^(nth-last-child|nth-last-of-type)\(/
+          if node.value[1].is_a?(Nokogiri::CSS::Node) and node.value[1].type == :AN_PLUS_B
+            an_plus_b(node.value[1], :last => true)
+          else
+            index = node.value[1].to_i - 1
+            index == 0 ? "position() = last()" : "position() = last() - #{index}"
           end
         when /^(first|first-of-type)\(/
           "position() = 1"
         when /^(last|last-of-type)\(/
           "position() = last()"
-        when /^(nth-last-child|nth-last-of-type)\(/
-          "position() = last() - #{node.value[1]}"
         when /^contains\(/
           "contains(., #{node.value[1]})"
         when /^gt\(/
@@ -31,6 +38,8 @@ module Nokogiri
           "last() = 1"
         when /^comment\(/
           "comment()"
+        when /^has\(/
+          node.value[1].accept(self)
         else
           args = ['.'] + node.value[1..-1]
           "#{node.value.first}#{args.join(', ')})"
@@ -38,20 +47,12 @@ module Nokogiri
       end
 
       def visit_not node
-        'not(' + node.value.first.accept(self) + ')'
-      end
-
-      def visit_preceding_selector node
-        node.value.last.accept(self) +
-          '[preceding-sibling::' +
-          node.value.first.accept(self) +
-          ']'
-      end
-
-      def visit_direct_adjacent_selector node
-        node.value.first.accept(self) +
-          "/following-sibling::*[1]/self::" +
-           node.value.last.accept(self)
+        child = node.value.first
+        if :ELEMENT_NAME == child.type
+          "not(self::#{child.accept(self)})"
+        else
+          "not(#{child.accept(self)})"
+        end
       end
 
       def visit_id node
@@ -76,15 +77,19 @@ module Nokogiri
         value = "'#{value}'" if value !~ /^['"]/
 
         case node.value[1]
-        when '*='
+        when :equal
+          attribute + " = " + "#{value}"
+        when :not_equal
+          attribute + " != " + "#{value}"
+        when :substring_match
           "contains(#{attribute}, #{value})"
-        when '^='
+        when :prefix_match
           "starts-with(#{attribute}, #{value})"
-        when '|='
+        when :dash_match
           "#{attribute} = #{value} or starts-with(#{attribute}, concat(#{value}, '-'))"
-        when '~='
+        when :includes
           "contains(concat(\" \", #{attribute}, \" \"),concat(\" \", #{value}, \" \"))"
-        when '$='
+        when :suffix_match
           "substring(#{attribute}, string-length(#{attribute}) - " +
             "string-length(#{value}) + 1, string-length(#{value})) = #{value}"
         else
@@ -100,8 +105,8 @@ module Nokogiri
           return self.send(msg, node) if self.respond_to?(msg)
 
           case node.value.first
-          when "first" then "position() = 1"
-          when "last" then "position() = last()"
+          when "first", "first-child" then "position() = 1"
+          when "last", "last-child" then "position() = last()"
           when "first-of-type" then "position() = 1"
           when "last-of-type" then "position() = last()"
           when "only-of-type" then "last() = 1"
@@ -118,9 +123,18 @@ module Nokogiri
         "contains(concat(' ', @class, ' '), ' #{node.value.first} ')"
       end
 
-      def visit_combinator node
-        node.value.first.accept(self) + ' and ' +
-        node.value.last.accept(self)
+      {
+        'combinator'                => ' and ',
+        'direct_adjacent_selector'  => "/following-sibling::*[1]/self::",
+        'preceding_selector'        => "/following-sibling::",
+        'descendant_selector'       => '//',
+        'child_selector'            => '/',
+      }.each do |k,v|
+        class_eval %{
+          def visit_#{k} node
+            "\#{node.value.first.accept(self)}#{v}\#{node.value.last.accept(self)}"
+          end
+        }
       end
 
       def visit_conditional_selector node
@@ -128,18 +142,6 @@ module Nokogiri
         node.value.last.accept(self) + ']'
       end
 
-      def visit_descendant_selector node
-        node.value.first.accept(self) +
-        '//' +
-        node.value.last.accept(self)
-      end
-
-      def visit_child_selector node
-        node.value.first.accept(self) +
-        '/' +
-        node.value.last.accept(self)
-      end
-
       def visit_element_name node
         node.value.first
       end
@@ -149,17 +151,18 @@ module Nokogiri
       end
 
     private
-      def an_plus_b node
+      def an_plus_b node, options={}
         raise ArgumentError, "expected an+b node to contain 4 tokens, but is #{node.value.inspect}" unless node.value.size == 4
 
         a = node.value[0].to_i
         b = node.value[3].to_i
+        position = options[:last] ? "(last()-position()+1)" : "position()"
 
         if (b == 0)
-          return "(position() mod #{a}) = 0"
+          return "(#{position} mod #{a}) = 0"
         else
           compare = (a < 0) ? "<=" : ">="
-          return "(position() #{compare} #{b}) and (((position()-#{b}) mod #{a.abs}) = 0)"
+          return "(#{position} #{compare} #{b}) and (((#{position}-#{b}) mod #{a.abs}) = 0)"
         end
       end