nokogiri 1.0.0-x86-mswin32-60

data/lib/nokogiri/css/generated_tokenizer.rb

@@ -0,0 +1,159 @@
+#
+# DO NOT MODIFY!!!!
+# This file is automatically generated by rex 1.0.1
+# from lexical definition file "lib/nokogiri/css/tokenizer.rex".
+#
+
+module Nokogiri
+module CSS
+class GeneratedTokenizer
+  require 'strscan'
+
+  class ScanError < StandardError ; end
+
+  attr_reader :lineno
+  attr_reader :filename
+
+  def scan_setup ; end
+
+  def action &block
+    yield
+  end
+
+  def scan_str( str )
+    scan_evaluate  str
+    do_parse
+  end
+
+  def load_file( filename )
+    @filename = filename
+    open(filename, "r") do |f|
+      scan_evaluate  f.read
+    end
+  end
+
+  def scan_file( filename )
+    load_file  filename
+    do_parse
+  end
+
+  def next_token
+    @rex_tokens.shift
+  end
+
+  def scan_evaluate( str )
+    scan_setup
+    @rex_tokens = []
+    @lineno  =  1
+    ss = StringScanner.new(str)
+    state = nil
+    until ss.eos?
+      text = ss.peek(1)
+      @lineno  +=  1  if text == "\n"
+      case state
+      when nil
+        case
+        when (text = ss.scan(/~=/i))
+           @rex_tokens.push action { [:INCLUDES, text] }
+
+        when (text = ss.scan(/\|=/i))
+           @rex_tokens.push action { [:DASHMATCH, text] }
+
+        when (text = ss.scan(/\^=/i))
+           @rex_tokens.push action { [:PREFIXMATCH, text] }
+
+        when (text = ss.scan(/\$=/i))
+           @rex_tokens.push action { [:SUFFIXMATCH, text] }
+
+        when (text = ss.scan(/\*=/i))
+           @rex_tokens.push action { [:SUBSTRINGMATCH, text] }
+
+        when (text = ss.scan(/!=/i))
+           @rex_tokens.push action { [:NOT_EQUAL, text] }
+
+        when (text = ss.scan(/[-]?([_a-z]|[^\0-\177]|\\[0-9a-f]{1,6}(\r\n|[\s\n\r\t\f])?|\\[^\n\r\f0-9a-f])([_a-z0-9-]|[^\0-\177]|\\[0-9a-f]{1,6}(\r\n|[\s\n\r\t\f])?|\\[^\n\r\f0-9a-f])*\(\s*/i))
+           @rex_tokens.push action { [:FUNCTION, text] }
+
+        when (text = ss.scan(/@[-]?([_a-z]|[^\0-\177]|\\[0-9a-f]{1,6}(\r\n|[\s\n\r\t\f])?|\\[^\n\r\f0-9a-f])([_a-z0-9-]|[^\0-\177]|\\[0-9a-f]{1,6}(\r\n|[\s\n\r\t\f])?|\\[^\n\r\f0-9a-f])*/i))
+           @rex_tokens.push action { [:IDENT, text] }
+
+        when (text = ss.scan(/[-]?([_a-z]|[^\0-\177]|\\[0-9a-f]{1,6}(\r\n|[\s\n\r\t\f])?|\\[^\n\r\f0-9a-f])([_a-z0-9-]|[^\0-\177]|\\[0-9a-f]{1,6}(\r\n|[\s\n\r\t\f])?|\\[^\n\r\f0-9a-f])*/i))
+           @rex_tokens.push action { [:IDENT, text] }
+
+        when (text = ss.scan(/-?([0-9]+|[0-9]*\.[0-9]+)/i))
+           @rex_tokens.push action { [:NUMBER, text] }
+
+        when (text = ss.scan(/\#([_a-z0-9-]|[^\0-\177]|\\[0-9a-f]{1,6}(\r\n|[\s\n\r\t\f])?|\\[^\n\r\f0-9a-f])+/i))
+           @rex_tokens.push action { [:HASH, text] }
+
+        when (text = ss.scan(/[\s\r\n\f]*\+/i))
+           @rex_tokens.push action { [:PLUS, text] }
+
+        when (text = ss.scan(/[\s\r\n\f]*>/i))
+           @rex_tokens.push action { [:GREATER, text] }
+
+        when (text = ss.scan(/[\s\r\n\f]*,/i))
+           @rex_tokens.push action { [:COMMA, text] }
+
+        when (text = ss.scan(/[\s\r\n\f]*~/i))
+           @rex_tokens.push action { [:TILDE, text] }
+
+        when (text = ss.scan(/\:not\(/i))
+           @rex_tokens.push action { [:NOT, text] }
+
+        when (text = ss.scan(/@[-]?([_a-z]|[^\0-\177]|\\[0-9a-f]{1,6}(\r\n|[\s\n\r\t\f])?|\\[^\n\r\f0-9a-f])([_a-z0-9-]|[^\0-\177]|\\[0-9a-f]{1,6}(\r\n|[\s\n\r\t\f])?|\\[^\n\r\f0-9a-f])*/i))
+           @rex_tokens.push action { [:ATKEYWORD, text] }
+
+        when (text = ss.scan(/-?([0-9]+|[0-9]*\.[0-9]+)%/i))
+           @rex_tokens.push action { [:PERCENTAGE, text] }
+
+        when (text = ss.scan(/-?([0-9]+|[0-9]*\.[0-9]+)[-]?([_a-z]|[^\0-\177]|\\[0-9a-f]{1,6}(\r\n|[\s\n\r\t\f])?|\\[^\n\r\f0-9a-f])([_a-z0-9-]|[^\0-\177]|\\[0-9a-f]{1,6}(\r\n|[\s\n\r\t\f])?|\\[^\n\r\f0-9a-f])*/i))
+           @rex_tokens.push action { [:DIMENSION, text] }
+
+        when (text = ss.scan(/<!--/i))
+           @rex_tokens.push action { [:CDO, text] }
+
+        when (text = ss.scan(/-->/i))
+           @rex_tokens.push action { [:CDC, text] }
+
+        when (text = ss.scan(/[\s\r\n\f]*\/\//i))
+           @rex_tokens.push action { [:DOUBLESLASH, text] }
+
+        when (text = ss.scan(/[\s\r\n\f]*\//i))
+           @rex_tokens.push action { [:SLASH, text] }
+
+        when (text = ss.scan(/U\+[0-9a-f?]{1,6}(-[0-9a-f]{1,6})?/i))
+           @rex_tokens.push action {[:UNICODE_RANGE, text] }
+
+        when (text = ss.scan(/\/\*(.|[\r\n])*?\*\//i))
+          ;
+
+        when (text = ss.scan(/[\s\t\r\n\f]+/i))
+           @rex_tokens.push action { [:S, text] }
+
+        when (text = ss.scan(/[\.*:\[\]=\)]/i))
+           @rex_tokens.push action { [text, text] }
+
+        when (text = ss.scan(/"([^\n\r\f"]|\\n|\r\n|\r|\f|[^\0-\177]|\\[0-9a-f]{1,6}(\r\n|[\s\n\r\t\f])?|\\[^\n\r\f0-9a-f])*"|'([^\n\r\f']|\\n|\r\n|\r|\f|[^\0-\177]|\\[0-9a-f]{1,6}(\r\n|[\s\n\r\t\f])?|\\[^\n\r\f0-9a-f])*'/i))
+           @rex_tokens.push action { [:STRING, text] }
+
+        when (text = ss.scan(/\"([^\n\r\f\"]|\\n|\r\n|\r|\f|[^\0-\177]|\\[0-9a-f]{1,6}(\r\n|[\s\n\r\t\f])?|\\[^\n\r\f0-9a-f])*|([^\n\r\f\']|\\n|\r\n|\r|\f|[^\0-\177]|\\[0-9a-f]{1,6}(\r\n|[\s\n\r\t\f])?|\\[^\n\r\f0-9a-f])*/i))
+           @rex_tokens.push action { [:INVALID, text] }
+
+        when (text = ss.scan(/./i))
+           @rex_tokens.push 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
+    end  # until ss
+  end  # def scan_evaluate
+
+end # class
+end
+end

data/lib/nokogiri/css/node.rb

@@ -0,0 +1,95 @@
+module Nokogiri
+  module CSS
+    class Node
+      attr_accessor :type, :value
+      def initialize type, value
+        @type = type
+        @value = value
+      end
+
+      def accept visitor
+        visitor.send(:"visit_#{type.to_s.downcase}", self)
+      end
+
+      def to_xpath prefix = '//', preprocess = true
+        self.preprocess! if preprocess
+        prefix + XPathVisitor.new.accept(self)
+      end
+
+      def preprocess!
+        ### Deal with nth-child
+        matches = find_by_type(
+          [:CONDITIONAL_SELECTOR,
+            [:ELEMENT_NAME],
+            [:PSEUDO_CLASS,
+              [:FUNCTION]
+            ]
+          ]
+        )
+        matches.each do |match|
+          if match.value[1].value[0].value[0] =~ /^nth-child/
+            tag_name = match.value[0].value.first
+            match.value[0].value = ['*']
+            match.value[1] = Node.new(:COMBINATOR, [
+              match.value[1].value[0],
+              Node.new(:FUNCTION, ['self(', tag_name])
+            ])
+          end
+          if match.value[1].value[0].value[0] =~ /^nth-last-child/
+            tag_name = match.value[0].value.first
+            match.value[0].value = ['*']
+            match.value[1] = Node.new(:COMBINATOR, [
+              match.value[1].value[0],
+              Node.new(:FUNCTION, ['self(', tag_name])
+            ])
+          end
+        end
+
+        ### Deal with first-child, last-child
+        matches = find_by_type(
+          [:CONDITIONAL_SELECTOR,
+            [:ELEMENT_NAME], [:PSEUDO_CLASS]
+        ])
+        matches.each do |match|
+          if ['first-child', 'last-child'].include?(match.value[1].value.first)
+            which = match.value[1].value.first.gsub(/-\w*$/, '')
+            tag_name = match.value[0].value.first
+            match.value[0].value = ['*']
+            match.value[1] = Node.new(:COMBINATOR, [
+              Node.new(:FUNCTION, ["#{which}("]),
+              Node.new(:FUNCTION, ['self(', tag_name])
+            ])
+          elsif 'only-child' == match.value[1].value.first
+            tag_name = match.value[0].value.first
+            match.value[0].value = ['*']
+            match.value[1] = Node.new(:COMBINATOR, [
+              Node.new(:FUNCTION, ["#{match.value[1].value.first}("]),
+              Node.new(:FUNCTION, ['self(', tag_name])
+            ])                                        
+          end
+        end
+
+        self
+      end
+
+      def find_by_type(types)
+        matches = []
+        matches << self if to_type == types
+        @value.each do |v|
+          matches += v.find_by_type(types) if v.respond_to?(:find_by_type)
+        end
+        matches
+      end
+
+      def to_type
+        [@type] + @value.map { |n|
+          n.to_type if n.respond_to?(:to_type)
+        }.compact
+      end
+
+      def to_a
+        [@type] + @value.map { |n| n.respond_to?(:to_a) ? n.to_a : [n] }
+      end
+    end
+  end
+end

data/lib/nokogiri/css/parser.rb

@@ -0,0 +1,24 @@
+module Nokogiri
+  module CSS
+    class Parser < GeneratedParser
+      class << self
+        def parse string
+          new.parse(string)
+        end
+      end
+
+      def initialize
+        @tokenizer = Tokenizer.new
+      end
+
+      def parse string
+        @tokenizer.scan string
+        do_parse
+      end
+
+      def next_token
+        @tokenizer.next_token
+      end
+    end
+  end
+end

data/lib/nokogiri/css/parser.y

@@ -0,0 +1,198 @@
+class Nokogiri::CSS::GeneratedParser
+
+token FUNCTION INCLUDES DASHMATCH LBRACE HASH PLUS GREATER S STRING IDENT
+token COMMA URI CDO CDC NUMBER PERCENTAGE LENGTH EMS EXS ANGLE TIME FREQ
+token IMPORTANT_SYM IMPORT_SYM MEDIA_SYM PAGE_SYM CHARSET_SYM DIMENSION
+token PREFIXMATCH SUFFIXMATCH SUBSTRINGMATCH TILDE NOT_EQUAL SLASH DOUBLESLASH
+token NOT
+
+rule
+  selector
+    : selector COMMA s_0toN simple_selector_1toN {
+        result = [val.first, val.last].flatten
+      }
+    | simple_selector_1toN { result = val.flatten }
+    ;
+  combinator
+    : PLUS s_0toN { result = :DIRECT_ADJACENT_SELECTOR }
+    | GREATER s_0toN { result = :CHILD_SELECTOR }
+    | TILDE s_0toN { result = :PRECEDING_SELECTOR }
+    | S { result = :DESCENDANT_SELECTOR }
+    | DOUBLESLASH s_0toN { result = :DESCENDANT_SELECTOR }
+    | SLASH s_0toN { 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
+      }
+    | element_name negation {
+        result = Node.new(:CONDITIONAL_SELECTOR, val)
+      }
+    | function
+    | function attrib {
+        result = Node.new(:CONDITIONAL_SELECTOR, val)
+      }
+    | hcap_1toN {
+        result = Node.new(:CONDITIONAL_SELECTOR,
+          [Node.new(:ELEMENT_NAME, ['*']), val.first]
+        )
+      }
+    ;
+  simple_selector_1toN
+    : simple_selector combinator simple_selector_1toN {
+        result = Node.new(val[1], [val.first, val.last])
+      }
+    | simple_selector
+    ;
+  class
+    : '.' IDENT { result = Node.new(:CLASS_CONDITION, [val[1]]) }
+    ;
+  element_name
+    : IDENT { result = Node.new(:ELEMENT_NAME, val) }
+    | '*' { result = Node.new(:ELEMENT_NAME, val) }
+    ;
+  attrib
+    : '[' s_0toN IDENT s_0toN attrib_val_0or1 ']' {
+        result = Node.new(:ATTRIBUTE_CONDITION,
+          [Node.new(:ELEMENT_NAME, [val[2]])] + (val[4] || [])
+        )
+      }
+    | '[' s_0toN function s_0toN attrib_val_0or1 ']' {
+        result = Node.new(:ATTRIBUTE_CONDITION,
+          [val[2]] + (val[4] || [])
+        )
+      }
+    | '[' s_0toN NUMBER s_0toN ']' {
+        # Non standard, but hpricot supports it.
+        result = Node.new(:PSEUDO_CLASS,
+          [Node.new(:FUNCTION, ['nth-child(', val[2]])]
+        )
+      }
+    ;
+  function
+    : FUNCTION ')' {
+        result = Node.new(:FUNCTION, [val.first.strip])
+      }
+    | FUNCTION expr ')' {
+        result = Node.new(:FUNCTION, [val.first.strip, val[1]].flatten)
+      }
+    | FUNCTION an_plus_b ')' {
+        result = Node.new(:FUNCTION, [val.first.strip, val[1]].flatten)
+      }
+    | NOT expr ')' {
+        result = Node.new(:FUNCTION, [val.first.strip, val[1]].flatten)
+      }
+    ;
+  expr
+    : NUMBER
+    | STRING
+    ;
+  an_plus_b
+    : NUMBER IDENT PLUS NUMBER          # 5n+3 -5n+3
+      {
+        if val[1] == 'n'
+          result = Node.new(:AN_PLUS_B, 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(:AN_PLUS_B, val)
+        elsif val[0] == '-n'
+          val[0] = 'n'
+          val.unshift("-1")
+          result = Node.new(:AN_PLUS_B, val)
+        else
+          raise Racc::ParseError, "parse error on IDENT '#{val[1]}'"
+        end
+      }
+    | NUMBER IDENT                      # 5n, -5n
+      {
+        if val[1] == 'n'
+          val << "+"
+          val << "0"
+          result = Node.new(:AN_PLUS_B, val)
+        else
+          raise Racc::ParseError, "parse error on IDENT '#{val[1]}'"
+        end
+      }
+    | IDENT                             # even, odd
+      {
+        if val[0] == 'even'
+          val = ["2","n","+","0"]
+          result = Node.new(:AN_PLUS_B, val)
+        elsif val[0] == 'odd'
+          val = ["2","n","+","1"]
+          result = Node.new(:AN_PLUS_B, val)
+        else
+          raise Racc::ParseError, "parse error on IDENT '#{val[0]}'"
+        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)
+      }
+    | attribute_id
+    | class
+    | attrib
+    | pseudo
+    ;
+  attribute_id
+    : HASH { result = Node.new(:ID, val) }
+    ;
+  attrib_val_0or1
+    : eql_incl_dash s_0toN IDENT s_0toN { result = [val.first, val[2]] }
+    | eql_incl_dash s_0toN STRING s_0toN { result = [val.first, val[2]] }
+    |
+    ;
+  eql_incl_dash
+    : '='
+    | PREFIXMATCH
+    | SUFFIXMATCH
+    | SUBSTRINGMATCH
+    | NOT_EQUAL
+    | INCLUDES
+    | DASHMATCH
+    ;
+  negation
+    : NOT s_0toN negation_arg s_0toN ')' {
+        result = Node.new(:NOT, [val[2]])
+      }
+    ;
+  negation_arg
+    : hcap_1toN
+    ;
+  s_0toN
+    : S s_0toN
+    |
+    ;
+end
+
+---- header
+