csspool 3.0.2 → 4.0.0.pre

data/lib/csspool/css/parser.y

@@ -3,7 +3,15 @@ class CSSPool::CSS::Parser
 token CHARSET_SYM IMPORT_SYM STRING SEMI IDENT S COMMA LBRACE RBRACE STAR HASH
 token LSQUARE RSQUARE EQUAL INCLUDES DASHMATCH RPAREN FUNCTION GREATER PLUS
 token SLASH NUMBER MINUS LENGTH PERCENTAGE EMS EXS ANGLE TIME FREQ URI
+token IMPORTANT_SYM MEDIA_SYM NTH_PSEUDO_CLASS
+token IMPORTANT_SYM MEDIA_SYM DOCUMENT_QUERY_SYM FUNCTION_NO_QUOTE
 token IMPORTANT_SYM MEDIA_SYM
+token NAMESPACE_SYM TILDE
+token NAMESPACE_SYM PREFIXMATCH SUFFIXMATCH SUBSTRINGMATCH
+token NAMESPACE_SYM NOT_PSEUDO_CLASS
+token NAMESPACE_SYM KEYFRAMES_SYM
+token NAMESPACE_SYM MATCHES_PSEUDO_CLASS
+token NAMESPACE_SYM MATH
 
 rule
   document
@@ -14,8 +22,10 @@ rule
   stylesheet
     : charset stylesheet
     | import stylesheet
+    | namespace stylesheet
     | charset
     | import
+    | namespace
     | body
     ;
   charset
@@ -34,6 +44,14 @@ rule
     | STRING { result = Terms::String.new interpret_string val.first }
     | URI { result = Terms::URI.new interpret_uri val.first }
     ;
+  namespace
+    : NAMESPACE_SYM ident import_location SEMI {
+        @handler.namespace val[1], val[2]
+      }
+    | NAMESPACE_SYM import_location SEMI {
+        @handler.namespace nil, val[1]
+      }
+    ;
   medium
     : medium COMMA IDENT {
         result = [val.first, Terms::Ident.new(interpret_identifier val.last)]
@@ -44,9 +62,15 @@ rule
     ;
   body
     : ruleset body
-    | media body
+    | conditional_rule body
+    | keyframes_rule body
     | ruleset
-    | media
+    | conditional_rule
+    | keyframes_rule
+    ;
+  conditional_rule
+    : media
+    | document_query
     ;
   media
     : start_media body RBRACE { @handler.end_media val.first }
@@ -58,6 +82,60 @@ rule
       }
     | MEDIA_SYM LBRACE { result = [] }
     ;
+  document_query
+    : start_document_query body RBRACE { @handler.end_document_query }
+    | start_document_query RBRACE { @handler.end_document_query }
+    ;
+  start_document_query
+    : DOCUMENT_QUERY_SYM url_match_fns LBRACE {
+        @handler.start_document_query val[1]
+      }
+    ;
+  url_match_fns
+    : url_match_fn COMMA url_match_fns {
+        result = [val[0], val[2]].flatten
+      }
+    | url_match_fn {
+        result = val
+      }
+    ;
+  url_match_fn
+    : function_no_quote
+    | function
+    | uri
+    ;
+  keyframes_rule
+    : start_keyframes_rule keyframes_blocks RBRACE
+    | start_keyframes_rule RBRACE
+    ;
+  start_keyframes_rule
+    : KEYFRAMES_SYM IDENT LBRACE {
+        @handler.start_keyframes_rule val[1]
+      }
+    ;
+  keyframes_blocks
+    : keyframes_block keyframes_blocks
+    | keyframes_block
+    ;
+  keyframes_block
+    : start_keyframes_block declarations RBRACE { @handler.end_keyframes_block }
+    | start_keyframes_block RBRACE { @handler.end_keyframes_block }
+    ;
+  start_keyframes_block
+    : keyframes_selectors LBRACE {
+        @handler.start_keyframes_block val[0]
+      }
+    ;
+  keyframes_selectors
+    | keyframes_selector COMMA keyframes_selectors {
+         result = val[0] + ', ' + val[2]
+      }
+    | keyframes_selector
+    ;
+  keyframes_selector
+    : IDENT
+    | PERCENTAGE { result = val[0].strip }
+    ;
   ruleset
     : start_selector declarations RBRACE {
         @handler.end_selector val.first
@@ -97,6 +175,7 @@ rule
     : S       { result = :s }
     | GREATER { result = :> }
     | PLUS    { result = :+ }
+    | TILDE   { result = :~ }
     ;
   simple_selector
     : element_name hcap {
@@ -112,9 +191,22 @@ rule
         result = [ss]
       }
     ;
+  simple_selectors
+    : simple_selector COMMA simple_selectors { result = [val[0], val[2]].flatten }
+    | simple_selector
+    ;
+  ident_with_namespace
+    : IDENT { result = [interpret_identifier(val[0]), nil] }
+    | IDENT '|' IDENT { result = [interpret_identifier(val[2]), interpret_identifier(val[0])] }
+    | '|' IDENT { result = [interpret_identifier(val[1]), nil] }
+    | STAR '|' IDENT { result = [interpret_identifier(val[2]), '*'] }
+    ;
   element_name
-    : IDENT { result = Selectors::Type.new interpret_identifier val.first }
-    | STAR  { result = Selectors::Universal.new val.first }
+    : ident_with_namespace { result = Selectors::Type.new val.first[0], nil, val.first[1] }
+    | STAR { result = Selectors::Universal.new val.first }
+    | '|' STAR { result = Selectors::Universal.new val[1] }
+    | STAR '|' STAR { result = Selectors::Universal.new val[2], nil, val[0] }
+    | IDENT '|' STAR { result = Selectors::Universal.new val[2], nil, interpret_identifier(val[0]) }
     ;
   hcap
     : hash        { result = val }
@@ -136,60 +228,118 @@ rule
       }
     ;
   attrib
-    : LSQUARE IDENT EQUAL IDENT RSQUARE {
+    : LSQUARE ident_with_namespace EQUAL IDENT RSQUARE {
         result = Selectors::Attribute.new(
-          interpret_identifier(val[1]),
+          val[1][0],
           interpret_identifier(val[3]),
-          Selectors::Attribute::EQUALS
+          Selectors::Attribute::EQUALS,
+          val[1][1]
         )
       }
-    | LSQUARE IDENT EQUAL STRING RSQUARE {
+    | LSQUARE ident_with_namespace EQUAL STRING RSQUARE {
         result = Selectors::Attribute.new(
-          interpret_identifier(val[1]),
+          val[1][0],
           interpret_string(val[3]),
-          Selectors::Attribute::EQUALS
+          Selectors::Attribute::EQUALS,
+          val[1][1]
         )
       }
-    | LSQUARE IDENT INCLUDES STRING RSQUARE {
+    | LSQUARE ident_with_namespace INCLUDES STRING RSQUARE {
         result = Selectors::Attribute.new(
-          interpret_identifier(val[1]),
+          val[1][0],
           interpret_string(val[3]),
-          Selectors::Attribute::INCLUDES
+          Selectors::Attribute::INCLUDES,
+          val[1][1]
         )
       }
-    | LSQUARE IDENT INCLUDES IDENT RSQUARE {
+    | LSQUARE ident_with_namespace INCLUDES IDENT RSQUARE {
         result = Selectors::Attribute.new(
-          interpret_identifier(val[1]),
+          val[1][0],
           interpret_identifier(val[3]),
-          Selectors::Attribute::INCLUDES
+          Selectors::Attribute::INCLUDES,
+          val[1][1]
         )
       }
-    | LSQUARE IDENT DASHMATCH IDENT RSQUARE {
+    | LSQUARE ident_with_namespace DASHMATCH IDENT RSQUARE {
         result = Selectors::Attribute.new(
-          interpret_identifier(val[1]),
+          val[1][0],
           interpret_identifier(val[3]),
-          Selectors::Attribute::DASHMATCH
+          Selectors::Attribute::DASHMATCH,
+          val[1][1]
         )
       }
-    | LSQUARE IDENT DASHMATCH STRING RSQUARE {
+    | LSQUARE ident_with_namespace DASHMATCH STRING RSQUARE {
         result = Selectors::Attribute.new(
-          interpret_identifier(val[1]),
+          val[1][0],
           interpret_string(val[3]),
-          Selectors::Attribute::DASHMATCH
+          Selectors::Attribute::DASHMATCH,
+          val[1][1]
         )
       }
-    | LSQUARE IDENT RSQUARE {
+    | LSQUARE ident_with_namespace PREFIXMATCH IDENT RSQUARE {
         result = Selectors::Attribute.new(
-          interpret_identifier(val[1]),
+          val[1][0],
+          interpret_identifier(val[3]),
+          Selectors::Attribute::PREFIXMATCH,
+          val[1][1]
+        )
+      }
+    | LSQUARE ident_with_namespace PREFIXMATCH STRING RSQUARE {
+        result = Selectors::Attribute.new(
+          val[1][0],
+          interpret_string(val[3]),
+          Selectors::Attribute::PREFIXMATCH,
+          val[1][1]
+        )
+      }
+    | LSQUARE ident_with_namespace SUFFIXMATCH IDENT RSQUARE {
+        result = Selectors::Attribute.new(
+          val[1][0],
+          interpret_identifier(val[3]),
+          Selectors::Attribute::SUFFIXMATCH,
+          val[1][1]
+        )
+      }
+    | LSQUARE ident_with_namespace SUFFIXMATCH STRING RSQUARE {
+        result = Selectors::Attribute.new(
+          val[1][0],
+          interpret_string(val[3]),
+          Selectors::Attribute::SUFFIXMATCH,
+          val[1][1]
+        )
+      }
+    | LSQUARE ident_with_namespace SUBSTRINGMATCH IDENT RSQUARE {
+        result = Selectors::Attribute.new(
+          val[1][0],
+          interpret_identifier(val[3]),
+          Selectors::Attribute::SUBSTRINGMATCH,
+          val[1][1]
+        )
+      }
+    | LSQUARE ident_with_namespace SUBSTRINGMATCH STRING RSQUARE {
+        result = Selectors::Attribute.new(
+          val[1][0],
+          interpret_string(val[3]),
+          Selectors::Attribute::SUBSTRINGMATCH,
+          val[1][1]
+        )
+      }
+    | LSQUARE ident_with_namespace RSQUARE {
+        result = Selectors::Attribute.new(
+          val[1][0],
           nil,
-          Selectors::Attribute::SET
+          Selectors::Attribute::SET,
+          val[1][1]
         )
       }
     ;
   pseudo
     : ':' IDENT {
-        result = Selectors::PseudoClass.new(
-          interpret_identifier(val[1])
+        result = Selectors::pseudo interpret_identifier(val[1])
+      }
+    | ':' ':' IDENT {
+        result = Selectors::PseudoElement.new(
+          interpret_identifier(val[2])
         )
       }
     | ':' FUNCTION RPAREN {
@@ -204,11 +354,36 @@ rule
           interpret_identifier(val[2])
         )
       }
+    | ':' NOT_PSEUDO_CLASS simple_selector RPAREN {
+        result = Selectors::PseudoClass.new(
+          'not',
+          val[2].first.to_s
+        )
+      }
+    | ':' NTH_PSEUDO_CLASS {
+        result = Selectors::PseudoClass.new(
+          interpret_identifier(val[1].sub(/\(.*/, '')),
+          interpret_identifier(val[1].sub(/.*\(/, '').sub(/\).*/, ''))
+        )
+      }
+    | ':' MATCHES_PSEUDO_CLASS simple_selectors RPAREN {
+        result = Selectors::PseudoClass.new(
+          val[1].split('(').first.strip,
+          val[2].join(', ')
+        )
+      }
+    ;
+  # declarations can be separated by one *or more* semicolons. semi-colons at the start or end of a ruleset are also allowed
+  one_or_more_semis
+    : SEMI
+    | SEMI one_or_more_semis
     ;
   declarations
-    : declaration SEMI declarations
-    | declaration SEMI
+    : declaration one_or_more_semis declarations
+    | one_or_more_semis declarations
+    | declaration one_or_more_semis
     | declaration
+    | one_or_more_semis
     ;
   declaration
     : property ':' expr prio
@@ -247,6 +422,7 @@ rule
     | string
     | uri
     | hexcolor
+    | math
     | function
     ;
   function
@@ -260,6 +436,22 @@ rule
         end
       }
     ;
+  function_no_quote
+    : function_no_quote S { result = val.first }
+    | FUNCTION_NO_QUOTE {
+        parts = val.first.split('(')
+        name = interpret_identifier parts.first
+        result = Terms::Function.new(name, [Terms::String.new(interpret_string_no_quote(parts.last))])
+      }
+    ;
+  math
+    : MATH {
+        parts = val.first.split('(', 2)
+        name = parts[0].strip
+        expression = parts[1][0..parts[1].rindex(')')-1].strip
+        result = Terms::Math.new(name, expression)
+      }
+    ;
   hexcolor
     : hexcolor S { result = val.first }
     | HASH { result = Terms::Hash.new val.first.sub(/^#/, '') }
@@ -267,6 +459,7 @@ rule
   uri
     : uri S { result = val.first }
     | URI { result = Terms::URI.new interpret_uri val.first }
+    ;
   string
     : string S { result = val.first }
     | STRING { result = Terms::String.new interpret_string val.first }
@@ -326,7 +519,11 @@ def interpret_identifier s
 end
 
 def interpret_uri s
-  interpret_escapes s.match(/^url\((.*)\)$/mu)[1].strip.match(/^(['"]?)((?:\\.|.)*)\1$/mu)[2]
+  interpret_escapes s.match(/^url\((.*)\)$/mui)[1].strip.match(/^(['"]?)((?:\\.|.)*)\1$/mu)[2]
+end
+
+def interpret_string_no_quote s
+  interpret_escapes s.match(/^(.*)\)$/mu)[1].strip.match(/^(['"]?)((?:\\.|.)*)\1$/mu)[2]
 end
 
 def interpret_string s

data/lib/csspool/css/tokenizer.rb

@@ -58,7 +58,7 @@ class Tokenizer < Parser
     token = case @state
     when nil
       case
-      when (text = @ss.scan(/url\([\s]*("([^\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])*')[\s]*\)/i))
+      when (text = @ss.scan(/url\([\s]*("([^\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])*')[\s]*\)/i))
          action { [:URI, st(text)] }
 
       when (text = @ss.scan(/url\([\s]*([!#\$%&*-~]|[^\0-\177]|\\[0-9A-Fa-f]{1,6}(\r\n|[\s])?|\\[^\n\r\f0-9A-Fa-f])*[\s]*\)/i))
@@ -70,6 +70,24 @@ class Tokenizer < Parser
       when (text = @ss.scan(/[\s]*\/\*(.|[\s]*)*?\*\/[\s]*/i))
          action { next_token }
 
+      when (text = @ss.scan(/not\(\s*/i))
+         action { [:NOT_PSEUDO_CLASS, st(text)] }
+
+      when (text = @ss.scan(/(nth\-child|nth\-last\-child|nth\-of\-type|nth\-last\-of\-type)\([\s]*([\+\-]?[0-9]*n([\s]*[\+\-][\s]*[0-9]+)?|[\+\-]?[0-9]+|odd|even)[\s]*\)/i))
+         action { [:NTH_PSEUDO_CLASS, st(text)] }
+
+      when (text = @ss.scan(/(\-[A-Za-z]+\-)?(matches|any)\(\s*/i))
+         action { [:MATCHES_PSEUDO_CLASS, st(text)] }
+
+      when (text = @ss.scan(/(domain|url\-prefix)\([\s]*("([^\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])*')[\s]*\)/i))
+         action { [:FUNCTION_NO_QUOTE, st(text)] }
+
+      when (text = @ss.scan(/(domain|url\-prefix)\([\s]*([!#\$%&*-~]|[^\0-\177]|\\[0-9A-Fa-f]{1,6}(\r\n|[\s])?|\\[^\n\r\f0-9A-Fa-f])*[\s]*\)/i))
+         action { [:FUNCTION_NO_QUOTE, st(text)] }
+
+      when (text = @ss.scan(/[\s]*(\-[A-Za-z]+\-)?calc\([\s]*(([0-9]*\.[0-9]+|[0-9]+)|([0-9]*\.[0-9]+|[0-9]+)(px|cm|mm|in|pt|pc)|([0-9]*\.[0-9]+|[0-9]+)%|([0-9]*\.[0-9]+|[0-9]+)em|([0-9]*\.[0-9]+|[0-9]+)ex)([\s]*(\*[\s]*(([0-9]*\.[0-9]+|[0-9]+)|([0-9]*\.[0-9]+|[0-9]+)(px|cm|mm|in|pt|pc)|([0-9]*\.[0-9]+|[0-9]+)%|([0-9]*\.[0-9]+|[0-9]+)em|([0-9]*\.[0-9]+|[0-9]+)ex)|\/[\s]*([0-9]*\.[0-9]+|[0-9]+)))*([\s]+[\+\-][\s]+(([0-9]*\.[0-9]+|[0-9]+)|([0-9]*\.[0-9]+|[0-9]+)(px|cm|mm|in|pt|pc)|([0-9]*\.[0-9]+|[0-9]+)%|([0-9]*\.[0-9]+|[0-9]+)em|([0-9]*\.[0-9]+|[0-9]+)ex)([\s]*(\*[\s]*(([0-9]*\.[0-9]+|[0-9]+)|([0-9]*\.[0-9]+|[0-9]+)(px|cm|mm|in|pt|pc)|([0-9]*\.[0-9]+|[0-9]+)%|([0-9]*\.[0-9]+|[0-9]+)em|([0-9]*\.[0-9]+|[0-9]+)ex)|\/[\s]*([0-9]*\.[0-9]+|[0-9]+)))*)*[\s]*\)[\s]*[\s]*/i))
+         action { [:MATH, st(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*/i))
          action { [:FUNCTION, st(text)] }
 
@@ -85,6 +103,15 @@ class Tokenizer < Parser
       when (text = @ss.scan(/[\s]*@media[\s]*/i))
          action { [:MEDIA_SYM, st(text)] }
 
+      when (text = @ss.scan(/[\s]*@(\-[A-Za-z]+\-)?document[\s]*/i))
+         action { [:DOCUMENT_QUERY_SYM, st(text)] }
+
+      when (text = @ss.scan(/[\s]*@namespace[\s]*/i))
+         action { [:NAMESPACE_SYM, st(text)] }
+
+      when (text = @ss.scan(/[\s]*@(\-[A-Za-z]+\-)?keyframes[\s]*/i))
+         action { [:KEYFRAMES_SYM, st(text)] }
+
       when (text = @ss.scan(/[\s]*!([\s]*|[\s]*\/\*(.|[\s]*)*?\*\/[\s]*)important[\s]*/i))
          action { [:IMPORTANT_SYM, st(text)] }
 
@@ -118,7 +145,7 @@ class Tokenizer < Parser
       when (text = @ss.scan(/[\s]*\)/i))
          action { [:RPAREN, st(text)] }
 
-      when (text = @ss.scan(/[\s]*\[[\s]*/i))
+      when (text = @ss.scan(/\[[\s]*/i))
          action { [:LSQUARE, st(text)] }
 
       when (text = @ss.scan(/[\s]*\]/i))
@@ -148,9 +175,6 @@ class Tokenizer < Parser
       when (text = @ss.scan(/[\s]*~[\s]*/i))
          action { [:TILDE, st(text)] }
 
-      when (text = @ss.scan(/\:not\([\s]*/i))
-         action { [:NOT, st(text)]  }
-
       when (text = @ss.scan(/[\s]*([0-9]*\.[0-9]+|[0-9]+)em[\s]*/i))
          action { [:EMS, st(text)] }
 
@@ -196,10 +220,10 @@ class Tokenizer < Parser
       when (text = @ss.scan(/[\s]+/i))
          action { [:S, st(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])*')/i))
+      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])*')/i))
          action { [:STRING, st(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])*)/i))
+      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])*)/i))
          action { [:INVALID, st(text)] }
 
       when (text = @ss.scan(/./i))

data/lib/csspool/css/tokenizer.rex

@@ -3,11 +3,17 @@ module CSS
 class Tokenizer < Parser
 
 macro
-  nl        \n|\r\n|\r|\f
+  nl        (\n|\r\n|\r|\f)
   w         [\s]*
   nonascii  [^\0-\177]
   num       ([0-9]*\.[0-9]+|[0-9]+)
+  length    {num}(px|cm|mm|in|pt|pc)
+  percentage {num}%
+  ems       {num}em
+  exs       {num}ex
   unicode   \\[0-9A-Fa-f]{1,6}(\r\n|[\s])?
+  nth       ([\+\-]?[0-9]*n({w}[\+\-]{w}[0-9]+)?|[\+\-]?[0-9]+|odd|even)
+  vendorprefix \-[A-Za-z]+\-
 
   escape    {unicode}|\\[^\n\r\f0-9A-Fa-f]
   nmchar    [_A-Za-z0-9-]|{nonascii}|{escape}
@@ -23,6 +29,12 @@ macro
   invalid   ({invalid1}|{invalid2})
   comment   \/\*(.|{w})*?\*\/
 
+  unit      ({num}|{length}|{percentage}|{ems}|{exs})
+  product   {unit}({w}(\*{w}{unit}|\/{w}{num}))*
+  sum       {product}([\s]+[\+\-][\s]+{product})*
+  calc      ({vendorprefix})?calc\({w}{sum}{w}\)
+  math      {calc}{w}
+
 rule
 
 # [:state]  pattern  [actions]
@@ -32,11 +44,29 @@ rule
             U\+[0-9a-fA-F?]{1,6}(-[0-9a-fA-F]{1,6})?  {[:UNICODE_RANGE, st(text)] }
             {w}{comment}{w}  { next_token }
 
+            # this one takes a selector as a parameter
+            not\(\s*         { [:NOT_PSEUDO_CLASS, st(text)] }
+
+            # this one takes an "nth" value
+            (nth\-child|nth\-last\-child|nth\-of\-type|nth\-last\-of\-type)\({w}{nth}{w}\) { [:NTH_PSEUDO_CLASS, st(text)] }
+
+            # this one takes a comma-separated list of simple selectors as a parameter
+            ({vendorprefix})?(matches|any)\(\s* { [:MATCHES_PSEUDO_CLASS, st(text)] }
+
+            # functions that can take an unquoted string parameter
+            (domain|url\-prefix)\({w}{string}{w}\) { [:FUNCTION_NO_QUOTE, st(text)] }
+            (domain|url\-prefix)\({w}([!#\$%&*-~]|{nonascii}|{escape})*{w}\) { [:FUNCTION_NO_QUOTE, st(text)] }
+
+            {w}{math}{w}     { [:MATH, st(text)] }
+
             {func}\(\s*      { [:FUNCTION, st(text)] }
             {w}@import{w}    { [:IMPORT_SYM, st(text)] }
             {w}@page{w}      { [:PAGE_SYM, st(text)] }
             {w}@charset{w}   { [:CHARSET_SYM, st(text)] }
             {w}@media{w}     { [:MEDIA_SYM, st(text)] }
+            {w}@({vendorprefix})?document{w} { [:DOCUMENT_QUERY_SYM, st(text)] }
+            {w}@namespace{w} { [:NAMESPACE_SYM, st(text)] }
+            {w}@({vendorprefix})?keyframes{w} { [:KEYFRAMES_SYM, st(text)] }
             {w}!({w}|{w}{comment}{w})important{w}  { [:IMPORTANT_SYM, st(text)] }
             {ident}          { [:IDENT, st(text)] }
             \#{name}         { [:HASH, st(text)] }
@@ -48,7 +78,7 @@ rule
             {w}!={w}         { [:NOT_EQUAL, st(text)] }
             {w}={w}          { [:EQUAL, st(text)] }
             {w}\)            { [:RPAREN, st(text)] }
-            {w}\[{w}         { [:LSQUARE, st(text)] }
+            \[{w}            { [:LSQUARE, st(text)] }
             {w}\]            { [:RSQUARE, st(text)] }
             {w}\+{w}         { [:PLUS, st(text)] }
             {w}\{{w}         { [:LBRACE, st(text)] }
@@ -58,16 +88,15 @@ rule
             {w};{w}          { [:SEMI, st(';')] }
             \*               { [:STAR, st(text)] }
             {w}~{w}          { [:TILDE, st(text)] }
-            \:not\({w}       { [:NOT, st(text)]  }
-            {w}{num}em{w}    { [:EMS, st(text)] }
-            {w}{num}ex{w}    { [:EXS, st(text)] }
+            {w}{ems}{w}      { [:EMS, st(text)] }
+            {w}{exs}{w}      { [:EXS, st(text)] }
 
-            {w}{num}(px|cm|mm|in|pt|pc){w}    { [:LENGTH, st(text)] }
+            {w}{length}{w}   { [:LENGTH, st(text)] }
             {w}{num}(deg|rad|grad){w} { [:ANGLE, st(text)] }
             {w}{num}(ms|s){w} { [:TIME, st(text)] }
             {w}{num}[k]?hz{w} { [:FREQ, st(text)] }
 
-            {w}{num}%{w}     { [:PERCENTAGE, st(text)] }
+            {w}{percentage}{w} { [:PERCENTAGE, st(text)] }
             {w}{num}{w}      { [:NUMBER, st(text)] }
             {w}\/\/{w}       { [:DOUBLESLASH, st(text)] }
             {w}\/{w}         { [:SLASH, st('/')] }

data/lib/csspool/css.rb

@@ -6,3 +6,7 @@ require 'csspool/css/rule_set'
 require 'csspool/css/declaration'
 require 'csspool/css/document'
 require 'csspool/css/document_handler'
+require 'csspool/css/document_query'
+require 'csspool/css/namespace_rule'
+require 'csspool/css/keyframes_rule'
+require 'csspool/css/keyframes_block'

data/lib/csspool/selector.rb

@@ -17,10 +17,14 @@ module CSSPool
     def specificity
       a = b = c = 0
       simple_selectors.each do |s|
-        c += 1
+        if !s.name.nil?
+          c += 1
+        end
         s.additional_selectors.each do |additional_selector|
           if Selectors::Id === additional_selector
             a += 1
+          elsif Selectors::PseudoElement === additional_selector
+            c += 1
           else
             b += 1
           end

data/lib/csspool/selectors/attribute.rb

@@ -4,17 +4,22 @@ module CSSPool
       attr_accessor :name
       attr_accessor :value
       attr_accessor :match_way
+      attr_accessor :namespace
 
       NO_MATCH  = 0
       SET       = 1
       EQUALS    = 2
       INCLUDES  = 3
       DASHMATCH = 4
+      PREFIXMATCH = 5
+      SUFFIXMATCH = 6
+      SUBSTRINGMATCH = 7
 
-      def initialize name, value, match_way
+      def initialize name, value, match_way, namespace = nil
         @name = name
         @value = value
         @match_way = match_way
+        @namespace = namespace
       end
     end
   end

data/lib/csspool/selectors/pseudo.rb

@@ -0,0 +1,17 @@
+require 'csspool/selectors/pseudo_class'
+require 'csspool/selectors/pseudo_element'
+
+module CSSPool
+  module Selectors
+    def Selectors.pseudo name
+      # FIXME: This is a bit of an ugly solution. Should be able to handle it
+      # more elegantly, and without calling out css2
+      css2_pseudo_elements = 
+      if %w{after before first-letter first-line}.include? name
+        PseudoElement.new name, true
+      else
+        PseudoClass.new name
+      end
+    end
+  end
+end

data/lib/csspool/selectors/pseudo_element.rb

@@ -0,0 +1,13 @@
+module CSSPool
+  module Selectors
+    class PseudoElement < CSSPool::Selectors::Additional
+      attr_accessor :name
+      attr_accessor :css2
+
+      def initialize name, css2 = nil
+        @name = name
+        @css2 = css2
+      end
+    end
+  end
+end

data/lib/csspool/selectors/simple.rb

@@ -1,10 +1,6 @@
 module CSSPool
   module Selectors
     class Simple < CSSPool::Node
-      NO_COMBINATOR       = 0
-      DESCENDENT          = 1
-      PRECEDED_BY         = 2
-      CHILD               = 3
 
       attr_accessor :name
       attr_accessor :parse_location

data/lib/csspool/selectors/type.rb

@@ -1,6 +1,13 @@
 module CSSPool
   module Selectors
     class Type < CSSPool::Selectors::Simple
+
+      attr_accessor :namespace
+
+      def initialize name, combinator = nil, namespace = nil
+        super name, combinator
+        @namespace = namespace
+      end
     end
   end
 end

data/lib/csspool/selectors/universal.rb

@@ -1,6 +1,13 @@
 module CSSPool
   module Selectors
     class Universal < CSSPool::Selectors::Simple
+
+      attr_accessor :namespace
+
+      def initialize name, combinator = nil, namespace = nil
+        super name, combinator
+        @namespace = namespace
+      end
     end
   end
 end

data/lib/csspool/selectors.rb

@@ -4,5 +4,5 @@ require 'csspool/selectors/type'
 require 'csspool/selectors/additional'
 require 'csspool/selectors/id'
 require 'csspool/selectors/class'
-require 'csspool/selectors/pseudo_class'
+require 'csspool/selectors/pseudo'
 require 'csspool/selectors/attribute'