Make parse error types extensible.

Author: jdm

Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 
 name = "cssparser"
-version = "0.13.5"
+version = "0.14.0"
 authors = [ "Simon Sapin <simon.sapin@exyr.org>" ]
 
 description = "Rust implementation of CSS Syntax Level 3"

src/color.rs

@@ -5,7 +5,7 @@
 use std::fmt;
 use std::f32::consts::PI;
 
-use super::{Token, Parser, ToCss, ParseError};
+use super::{Token, Parser, ToCss, ParseError, BasicParseError};
 use tokenizer::NumericValue;
 
 #[cfg(feature = "serde")]
@@ -141,7 +141,7 @@ impl Color {
     /// Parse a <color> value, per CSS Color Module Level 3.
     ///
     /// FIXME(#2) Deprecated CSS2 System Colors are not supported yet.
-    pub fn parse<'i, 't>(input: &mut Parser<'i, 't>) -> Result<Color, ParseError<'i>> {
+    pub fn parse<'i, 't>(input: &mut Parser<'i, 't>) -> Result<Color, BasicParseError<'i>> {
         let token = try!(input.next());
         match token {
             Token::Hash(ref value) | Token::IDHash(ref value) => {
@@ -151,10 +151,11 @@ impl Color {
             Token::Function(ref name) => {
                 return input.parse_nested_block(|arguments| {
                     parse_color_function(&*name, arguments)
-                });
+                        .map_err(|e| ParseError::Basic(e))
+                }).map_err(ParseError::<()>::basic);
             }
             _ => Err(())
-        }.map_err(|()| ParseError::UnexpectedToken(token))
+        }.map_err(|()| BasicParseError::UnexpectedToken(token))
     }
 
     /// Parse a color hash, without the leading '#' character.
@@ -411,11 +412,11 @@ fn clamp_floor_256_f32(val: f32) -> u8 {
 }
 
 #[inline]
-fn parse_color_function<'i, 't>(name: &str, arguments: &mut Parser<'i, 't>) -> Result<Color, ParseError<'i>> {
+fn parse_color_function<'i, 't>(name: &str, arguments: &mut Parser<'i, 't>) -> Result<Color, BasicParseError<'i>> {
     let (red, green, blue, uses_commas) = match_ignore_ascii_case! { name,
         "rgb" | "rgba" => parse_rgb_components_rgb(arguments)?,
         "hsl" | "hsla" => parse_rgb_components_hsl(arguments)?,
-        _ => return Err(ParseError::UnexpectedToken(Token::Ident(name.to_owned().into()))),
+        _ => return Err(BasicParseError::UnexpectedToken(Token::Ident(name.to_owned().into()))),
     };
 
     let alpha = if !arguments.is_exhausted() {
@@ -424,7 +425,7 @@ fn parse_color_function<'i, 't>(name: &str, arguments: &mut Parser<'i, 't>) -> R
         } else {
             match try!(arguments.next()) {
                 Token::Delim('/') => {},
-                t => return Err(ParseError::UnexpectedToken(t)),
+                t => return Err(BasicParseError::UnexpectedToken(t)),
             };
         };
         let token = try!(arguments.next());
@@ -436,7 +437,7 @@ fn parse_color_function<'i, 't>(name: &str, arguments: &mut Parser<'i, 't>) -> R
                 clamp_unit_f32(v.unit_value)
             }
             t => {
-                return Err(ParseError::UnexpectedToken(t))
+                return Err(BasicParseError::UnexpectedToken(t))
             }
         }
     } else {
@@ -449,7 +450,7 @@ fn parse_color_function<'i, 't>(name: &str, arguments: &mut Parser<'i, 't>) -> R
 
 
 #[inline]
-fn parse_rgb_components_rgb<'i, 't>(arguments: &mut Parser<'i, 't>) -> Result<(u8, u8, u8, bool), ParseError<'i>> {
+fn parse_rgb_components_rgb<'i, 't>(arguments: &mut Parser<'i, 't>) -> Result<(u8, u8, u8, bool), BasicParseError<'i>> {
     let red: u8;
     let green: u8;
     let blue: u8;
@@ -466,7 +467,7 @@ fn parse_rgb_components_rgb<'i, 't>(arguments: &mut Parser<'i, 't>) -> Result<(u
                     uses_commas = true;
                     try!(arguments.expect_number())
                 }
-                t => return Err(ParseError::UnexpectedToken(t))
+                t => return Err(BasicParseError::UnexpectedToken(t))
             });
             if uses_commas {
                 try!(arguments.expect_comma());
@@ -481,20 +482,20 @@ fn parse_rgb_components_rgb<'i, 't>(arguments: &mut Parser<'i, 't>) -> Result<(u
                     uses_commas = true;
                     try!(arguments.expect_percentage())
                 }
-                t => return Err(ParseError::UnexpectedToken(t))
+                t => return Err(BasicParseError::UnexpectedToken(t))
             });
             if uses_commas {
                 try!(arguments.expect_comma());
             }
             blue = clamp_unit_f32(try!(arguments.expect_percentage()));
         }
-        t => return Err(ParseError::UnexpectedToken(t))
+        t => return Err(BasicParseError::UnexpectedToken(t))
     };
     return Ok((red, green, blue, uses_commas));
 }
 
 #[inline]
-fn parse_rgb_components_hsl<'i, 't>(arguments: &mut Parser<'i, 't>) -> Result<(u8, u8, u8, bool), ParseError<'i>> {
+fn parse_rgb_components_hsl<'i, 't>(arguments: &mut Parser<'i, 't>) -> Result<(u8, u8, u8, bool), BasicParseError<'i>> {
     let mut uses_commas = false;
     // Hue given as an angle
     // https://drafts.csswg.org/css-values/#angles
@@ -510,9 +511,9 @@ fn parse_rgb_components_hsl<'i, 't>(arguments: &mut Parser<'i, 't>) -> Result<(u
                 _ => Err(()),
             }
         }
-        t => return Err(ParseError::UnexpectedToken(t))
+        t => return Err(BasicParseError::UnexpectedToken(t))
     };
-    let hue_degrees = try!(hue_degrees.map_err(|()| ParseError::UnexpectedToken(token)));
+    let hue_degrees = try!(hue_degrees.map_err(|()| BasicParseError::UnexpectedToken(token)));
     // Subtract an integer before rounding, to avoid some rounding errors:
     let hue_normalized_degrees = hue_degrees - 360. * (hue_degrees / 360.).floor();
     let hue = hue_normalized_degrees / 360.;
@@ -525,7 +526,7 @@ fn parse_rgb_components_hsl<'i, 't>(arguments: &mut Parser<'i, 't>) -> Result<(u
             uses_commas = true;
             try!(arguments.expect_percentage())
         }
-        t => return Err(ParseError::UnexpectedToken(t))
+        t => return Err(BasicParseError::UnexpectedToken(t))
     };
     let saturation = saturation.max(0.).min(1.);
 

src/lib.rs

@@ -89,7 +89,7 @@ pub use from_bytes::{stylesheet_encoding, EncodingSupport};
 pub use color::{RGBA, Color, parse_color_keyword};
 pub use nth::parse_nth;
 pub use serializer::{ToCss, CssStringWriter, serialize_identifier, serialize_string, TokenSerializationType};
-pub use parser::{Parser, Delimiter, Delimiters, SourcePosition, ParseError};
+pub use parser::{Parser, Delimiter, Delimiters, SourcePosition, ParseError, BasicParseError};
 pub use unicode_range::UnicodeRange;
 
 // For macros

src/nth.rs

@@ -4,14 +4,14 @@
 
 use std::ascii::AsciiExt;
 
-use super::{Token, Parser, ParseError};
+use super::{Token, Parser, BasicParseError};
 
 
 /// Parse the *An+B* notation, as found in the `:nth-child()` selector.
 /// The input is typically the arguments of a function,
 /// in which case the caller needs to check if the arguments’ parser is exhausted.
 /// Return `Ok((A, B))`, or `Err(())` for a syntax error.
-pub fn parse_nth<'i, 't>(input: &mut Parser<'i, 't>) -> Result<(i32, i32), ParseError<'i>> {
+pub fn parse_nth<'i, 't>(input: &mut Parser<'i, 't>) -> Result<(i32, i32), BasicParseError<'i>> {
     let token = try!(input.next());
     match token {
         Token::Number(ref value) => {
@@ -59,14 +59,14 @@ pub fn parse_nth<'i, 't>(input: &mut Parser<'i, 't>) -> Result<(i32, i32), Parse
                     _ => parse_n_dash_digits(&*value).map(|v| (1, v))
                 }
             }
-            t => return Err(ParseError::UnexpectedToken(t)),
+            t => return Err(BasicParseError::UnexpectedToken(t)),
         },
         _ => Err(()),
-    }.map_err(|()| ParseError::UnexpectedToken(token))
+    }.map_err(|()| BasicParseError::UnexpectedToken(token))
 }
 
 
-fn parse_b<'i, 't>(input: &mut Parser<'i, 't>, a: i32) -> Result<(i32, i32), ParseError<'i>> {
+fn parse_b<'i, 't>(input: &mut Parser<'i, 't>, a: i32) -> Result<(i32, i32), BasicParseError<'i>> {
     let start_position = input.position();
     let token = input.next();
     match token {
@@ -82,10 +82,10 @@ fn parse_b<'i, 't>(input: &mut Parser<'i, 't>, a: i32) -> Result<(i32, i32), Par
             input.reset(start_position);
             Ok((a, 0))
         }
-    }.map_err(|()| ParseError::UnexpectedToken(token.unwrap()))
+    }.map_err(|()| BasicParseError::UnexpectedToken(token.unwrap()))
 }
 
-fn parse_signless_b<'i, 't>(input: &mut Parser<'i, 't>, a: i32, b_sign: i32) -> Result<(i32, i32), ParseError<'i>> {
+fn parse_signless_b<'i, 't>(input: &mut Parser<'i, 't>, a: i32, b_sign: i32) -> Result<(i32, i32), BasicParseError<'i>> {
     let token = try!(input.next());
     match token {
         Token::Number(ref value) if !value.has_sign => {
@@ -95,7 +95,7 @@ fn parse_signless_b<'i, 't>(input: &mut Parser<'i, 't>, a: i32, b_sign: i32) ->
             }
         }
         _ => Err(())
-    }.map_err(|()| ParseError::UnexpectedToken(token))
+    }.map_err(|()| BasicParseError::UnexpectedToken(token))
 }
 
 fn parse_n_dash_digits(string: &str) -> Result<i32, ()> {