[librsvg: 25/43] Convert Angle, MarkerOrient to CssParseError

[Federico Mena Quintero <federico src gnome org>]

commit a1d25b538806b5dd91dd8d129baee112deb73570
Author: Federico Mena Quintero <federico gnome org>
Date:   Fri Dec 20 17:53:47 2019 -0600

    Convert Angle, MarkerOrient to CssParseError

 rsvg_internals/src/angle.rs  | 40 +++++++++++++++++++---------------------
 rsvg_internals/src/marker.rs | 44 ++++++++++++++++++++++++++------------------
 2 files changed, 45 insertions(+), 39 deletions(-)
---
diff --git a/rsvg_internals/src/angle.rs b/rsvg_internals/src/angle.rs
index ebd86d77..86ecbd13 100644
--- a/rsvg_internals/src/angle.rs
+++ b/rsvg_internals/src/angle.rs
@@ -4,8 +4,8 @@ use std::f64::consts::*;
 
 use cssparser::{Parser, Token};
 
-use crate::error::ValueErrorKind;
-use crate::parsers::{finite_f32, Parse};
+use crate::error::*;
+use crate::parsers::{finite_f32, ParseToParseError};
 
 #[derive(Debug, Copy, Clone, PartialEq)]
 pub struct Angle(f64);
@@ -61,41 +61,39 @@ impl Angle {
 //
 // angle ::= number ("deg" | "grad" | "rad")?
 //
-impl Parse for Angle {
-    fn parse(parser: &mut Parser<'_, '_>) -> Result<Angle, ValueErrorKind> {
+impl ParseToParseError for Angle {
+    fn parse_to_parse_error<'i>(parser: &mut Parser<'i, '_>) -> Result<Angle, CssParseError<'i>> {
         let angle = {
+            let loc = parser.current_source_location();
+
             let token = parser.next()?;
 
             match *token {
                 Token::Number { value, .. } => {
-                    let degrees = finite_f32(value)?;
+                    let degrees = finite_f32(value).map_err(|e| loc.new_custom_error(e))?;
                     Angle::from_degrees(f64::from(degrees))
                 }
 
                 Token::Dimension {
                     value, ref unit, ..
                 } => {
-                    let value = f64::from(finite_f32(value)?);
+                    let value = f64::from(finite_f32(value).map_err(|e| loc.new_custom_error(e))?);
 
                     match unit.as_ref() {
                         "deg" => Angle::from_degrees(value),
                         "grad" => Angle::from_degrees(value * 360.0 / 400.0),
                         "rad" => Angle::new(value),
                         _ => {
-                            return Err(ValueErrorKind::parse_error(
-                                "expected 'deg' | 'grad' | 'rad'",
-                            ));
+                            return Err(loc.new_unexpected_token_error(token.clone()));
                         }
                     }
                 }
 
-                _ => return Err(ValueErrorKind::parse_error("expected angle")),
+                _ => return Err(loc.new_unexpected_token_error(token.clone())),
             }
         };
 
-        parser
-            .expect_exhausted()
-            .map_err(|_| ValueErrorKind::parse_error("expected angle"))?;
+        parser.expect_exhausted()?;
 
         Ok(angle)
     }
@@ -109,18 +107,18 @@ mod tests {
 
     #[test]
     fn parses_angle() {
-        assert_eq!(Angle::parse_str("0"), Ok(Angle::new(0.0)));
-        assert_eq!(Angle::parse_str("15"), Ok(Angle::from_degrees(15.0)));
-        assert_eq!(Angle::parse_str("180.5deg"), Ok(Angle::from_degrees(180.5)));
-        assert_eq!(Angle::parse_str("1rad"), Ok(Angle::new(1.0)));
+        assert_eq!(Angle::parse_str_to_parse_error("0"), Ok(Angle::new(0.0)));
+        assert_eq!(Angle::parse_str_to_parse_error("15"), Ok(Angle::from_degrees(15.0)));
+        assert_eq!(Angle::parse_str_to_parse_error("180.5deg"), Ok(Angle::from_degrees(180.5)));
+        assert_eq!(Angle::parse_str_to_parse_error("1rad"), Ok(Angle::new(1.0)));
         assert_eq!(
-            Angle::parse_str("-400grad"),
+            Angle::parse_str_to_parse_error("-400grad"),
             Ok(Angle::from_degrees(-360.0))
         );
 
-        assert!(Angle::parse_str("").is_err());
-        assert!(Angle::parse_str("foo").is_err());
-        assert!(Angle::parse_str("300foo").is_err());
+        assert!(Angle::parse_str_to_parse_error("").is_err());
+        assert!(Angle::parse_str_to_parse_error("foo").is_err());
+        assert!(Angle::parse_str_to_parse_error("300foo").is_err());
     }
 
     fn test_bisection_angle(
diff --git a/rsvg_internals/src/marker.rs b/rsvg_internals/src/marker.rs
index ec6939b6..a327b281 100644
--- a/rsvg_internals/src/marker.rs
+++ b/rsvg_internals/src/marker.rs
@@ -60,15 +60,17 @@ impl Default for MarkerOrient {
     }
 }
 
-impl Parse for MarkerOrient {
-    fn parse(parser: &mut Parser<'_, '_>) -> Result<MarkerOrient, ValueErrorKind> {
+impl ParseToParseError for MarkerOrient {
+    fn parse_to_parse_error<'i>(
+        parser: &mut Parser<'i, '_>,
+    ) -> Result<MarkerOrient, CssParseError<'i>> {
         if parser
             .try_parse(|p| p.expect_ident_matching("auto"))
             .is_ok()
         {
             Ok(MarkerOrient::Auto)
         } else {
-            Angle::parse(parser).map(MarkerOrient::Angle)
+            Angle::parse_to_parse_error(parser).map(MarkerOrient::Angle)
         }
     }
 }
@@ -186,16 +188,22 @@ impl NodeTrait for Marker {
                 expanded_name!(svg "refX") => self.ref_x = attr.parse_to_parse_error(value)?,
                 expanded_name!(svg "refY") => self.ref_y = attr.parse_to_parse_error(value)?,
                 expanded_name!(svg "markerWidth") => {
-                    self.width =
-                        attr.parse_to_parse_error_and_validate(value, 
Length::<Horizontal>::check_nonnegative)?
+                    self.width = attr.parse_to_parse_error_and_validate(
+                        value,
+                        Length::<Horizontal>::check_nonnegative,
+                    )?
                 }
                 expanded_name!(svg "markerHeight") => {
-                    self.height =
-                        attr.parse_to_parse_error_and_validate(value, Length::<Vertical>::check_nonnegative)?
+                    self.height = attr.parse_to_parse_error_and_validate(
+                        value,
+                        Length::<Vertical>::check_nonnegative,
+                    )?
                 }
-                expanded_name!(svg "orient") => self.orient = attr.parse(value)?,
+                expanded_name!(svg "orient") => self.orient = attr.parse_to_parse_error(value)?,
                 expanded_name!(svg "preserveAspectRatio") => self.aspect = attr.parse(value)?,
-                expanded_name!(svg "viewBox") => self.vbox = Some(attr.parse_to_parse_error(value)?),
+                expanded_name!(svg "viewBox") => {
+                    self.vbox = Some(attr.parse_to_parse_error(value)?)
+                }
                 _ => (),
             }
         }
@@ -823,33 +831,33 @@ mod parser_tests {
 
     #[test]
     fn parsing_invalid_marker_orient_yields_error() {
-        assert!(MarkerOrient::parse_str("").is_err());
-        assert!(MarkerOrient::parse_str("blah").is_err());
-        assert!(MarkerOrient::parse_str("45blah").is_err());
+        assert!(MarkerOrient::parse_str_to_parse_error("").is_err());
+        assert!(MarkerOrient::parse_str_to_parse_error("blah").is_err());
+        assert!(MarkerOrient::parse_str_to_parse_error("45blah").is_err());
     }
 
     #[test]
     fn parses_marker_orient() {
-        assert_eq!(MarkerOrient::parse_str("auto"), Ok(MarkerOrient::Auto));
+        assert_eq!(MarkerOrient::parse_str_to_parse_error("auto"), Ok(MarkerOrient::Auto));
 
         assert_eq!(
-            MarkerOrient::parse_str("0"),
+            MarkerOrient::parse_str_to_parse_error("0"),
             Ok(MarkerOrient::Angle(Angle::new(0.0)))
         );
         assert_eq!(
-            MarkerOrient::parse_str("180"),
+            MarkerOrient::parse_str_to_parse_error("180"),
             Ok(MarkerOrient::Angle(Angle::from_degrees(180.0)))
         );
         assert_eq!(
-            MarkerOrient::parse_str("180deg"),
+            MarkerOrient::parse_str_to_parse_error("180deg"),
             Ok(MarkerOrient::Angle(Angle::from_degrees(180.0)))
         );
         assert_eq!(
-            MarkerOrient::parse_str("-400grad"),
+            MarkerOrient::parse_str_to_parse_error("-400grad"),
             Ok(MarkerOrient::Angle(Angle::from_degrees(-360.0)))
         );
         assert_eq!(
-            MarkerOrient::parse_str("1rad"),
+            MarkerOrient::parse_str_to_parse_error("1rad"),
             Ok(MarkerOrient::Angle(Angle::new(1.0)))
         );
     }