Add An+B parsing.

Author: SimonSapin

ast.rs

@@ -134,17 +134,17 @@ pub trait SkipWhitespaceIterable<'self> {
 
 impl<'self> SkipWhitespaceIterable<'self> for &'self [ComponentValue] {
     pub fn skip_whitespace(self) -> SkipWhitespaceIterator<'self> {
-        SkipWhitespaceIterator{ iter: self.iter() }
+        SkipWhitespaceIterator{ iter_with_whitespace: self.iter() }
     }
 }
 
-struct SkipWhitespaceIterator<'self> {
-    iter: vec::VecIterator<'self, ComponentValue>,
+pub struct SkipWhitespaceIterator<'self> {
+    iter_with_whitespace: vec::VecIterator<'self, ComponentValue>,
 }
 
 impl<'self> Iterator<&'self ComponentValue> for SkipWhitespaceIterator<'self> {
     fn next(&mut self) -> Option<&'self ComponentValue> {
-        for component_value in self.iter {
+        for component_value in self.iter_with_whitespace {
             if component_value != &WhiteSpace { return Some(component_value) }
         }
         None
@@ -162,7 +162,7 @@ impl ConsumeSkipWhitespaceIterable for ~[ComponentValue] {
     }
 }
 
-struct ConsumeSkipWhitespaceIterator {
+pub struct ConsumeSkipWhitespaceIterator {
     iter: vec::ConsumeIterator<ComponentValue>,
 }
 

cssparser.rc

@@ -11,11 +11,13 @@ pub use ast::*;
 pub use tokenizer::*;
 pub use parser::*;
 pub use color::*;
+pub use nth::*;
 
 mod ast;
 mod tokenizer;
 mod parser;
 mod color;
+mod nth;
 
 #[cfg(test)]
 mod tests;

nth.rs

@@ -0,0 +1,119 @@
+use std::i32;
+use std::ascii::to_ascii_lower;
+use ast::*;
+
+
+/// Parse the An+B notation, as found in the ``:nth-child()`` selector.
+/// The input is typically the arguments of a function component value.
+/// Return Some((A, B)), or None for a syntax error.
+pub fn parse_nth(input: &[ComponentValue]) -> Option<(i32, i32)> {
+    let iter = &mut input.skip_whitespace();
+    match iter.next() {
+        Some(&Number(ref value)) => match value.int_value {
+            Some(b) => parse_end(iter, 0, b as i32),
+            _ => None,
+        },
+        Some(&Dimension(ref value, ref unit)) => match value.int_value {
+            Some(a) => {
+                let unit: &str = to_ascii_lower(unit.as_slice());
+                match unit {
+                    "n" => parse_b(iter, a as i32),
+                    "n-" => parse_signless_b(iter, a as i32, -1),
+                    _ => match(parse_n_dash_digits(unit)) {
+                        Some(b) => parse_end(iter, a as i32, b),
+                        _ => None
+                    },
+                }
+            },
+            _ => None,
+        },
+        Some(&Ident(ref value)) => {
+            let ident: &str = to_ascii_lower(value.as_slice());
+            match ident {
+                "even" => parse_end(iter, 2, 0),
+                "odd" => parse_end(iter, 2, 1),
+                "n" => parse_b(iter, 1),
+                "-n" => parse_b(iter, -1),
+                "n-" => parse_signless_b(iter, 1, -1),
+                "-n-" => parse_signless_b(iter, -1, -1),
+                _ if ident.starts_with("-") => match(parse_n_dash_digits(ident.slice_from(1))) {
+                    Some(b) => parse_end(iter, -1, b),
+                    _ => None
+                },
+                _ =>  match(parse_n_dash_digits(ident)) {
+                    Some(b) => parse_end(iter, 1, b),
+                    _ => None
+                },
+            }
+        },
+        Some(&Delim('+')) => match iter.iter_with_whitespace.next() {
+            Some(&Ident(ref value)) => {
+                let ident: &str = to_ascii_lower(value.as_slice());
+                match ident {
+                    "n" => parse_b(iter, 1),
+                    "n-" => parse_signless_b(iter, 1, -1),
+                    _ => match(parse_n_dash_digits(ident)) {
+                        Some(b) => parse_end(iter, 1, b),
+                        _ => None
+                    },
+                }
+            },
+            _ => None
+        },
+        _ => None
+    }
+}
+
+
+type Nth = Option<(i32, i32)>;
+type Iter<'self> = SkipWhitespaceIterator<'self>;
+
+fn parse_b(iter: &mut Iter, a: i32) -> Nth {
+    match iter.next() {
+        None => Some((a, 0)),
+        Some(&Delim('+')) => parse_signless_b(iter, a, 1),
+        Some(&Delim('-')) => parse_signless_b(iter, a, -1),
+        Some(&Number(ref value)) => match value.int_value {
+            Some(b) if has_sign(value) => parse_end(iter, a, b as i32),
+            _ => None,
+        },
+        _ => None
+    }
+}
+
+fn parse_signless_b(iter: &mut Iter, a: i32, b_sign: i32) -> Nth {
+    match iter.next() {
+        Some(&Number(ref value)) => match value.int_value {
+            Some(b) if !has_sign(value) => parse_end(iter, a, b_sign * (b as i32)),
+            _ => None,
+        },
+        _ => None
+    }
+}
+
+fn parse_end(iter: &mut Iter, a: i32, b: i32) -> Nth {
+    match iter.next() {
+        None => Some((a, b)),
+        Some(_) => None,
+    }
+}
+
+fn parse_n_dash_digits(string: &str) -> Option<i32> {
+    if string.len() >= 3
+    && string.starts_with("n-")
+    && string.slice_from(2).iter().all(|c| match c { '0'..'9' => true, _ => false })
+    {
+        let result = i32::from_str(string.slice_from(1));  // Include the minus sign
+        assert!(result.is_some());
+        result
+    }
+    else { None }
+}
+
+#[inline]
+fn has_sign(value: &NumericValue) -> bool {
+    match value.representation[0] as char {
+        '+' | '-' => true,
+        _ => false
+    }
+}

tests.rs

@@ -164,6 +164,14 @@ fn color3_keywords() {
 }
 
 
+#[test]
+fn nth() {
+    do run_json_tests(include_str!("css-parsing-tests/An+B.json")) |input| {
+        parse_nth(tokenize(input).transform(|(c, _)| c).to_owned_vec())
+    }
+}
+
+
 impl ToJson for Result<Rule, SyntaxError> {
     fn to_json(&self) -> json::Json {
         match *self {