[librsvg: 42/43] The Great Renaming is done!
- From: Federico Mena Quintero <federico src gnome org>
- To: commits-list gnome org
- Cc:
- Subject: [librsvg: 42/43] The Great Renaming is done!
- Date: Sat, 21 Dec 2019 02:33:01 +0000 (UTC)
commit f7f70fe561704e2f5a00a38b895e05222b39e034
Author: Federico Mena Quintero <federico gnome org>
Date: Fri Dec 20 20:08:54 2019 -0600
The Great Renaming is done!
rsvg_internals/src/angle.rs | 22 ++--
rsvg_internals/src/aspect_ratio.rs | 70 ++++++------
rsvg_internals/src/clip_path.rs | 4 +-
rsvg_internals/src/color.rs | 18 ++-
rsvg_internals/src/cond.rs | 8 +-
rsvg_internals/src/coord_units.rs | 20 ++--
rsvg_internals/src/create_node.rs | 13 ++-
rsvg_internals/src/css.rs | 11 +-
rsvg_internals/src/dasharray.rs | 68 ++++--------
rsvg_internals/src/document.rs | 1 -
rsvg_internals/src/drawing_ctx.rs | 11 +-
rsvg_internals/src/error.rs | 10 +-
rsvg_internals/src/filter.rs | 31 +++---
rsvg_internals/src/filters/blend.rs | 10 +-
rsvg_internals/src/filters/color_matrix.rs | 30 ++---
rsvg_internals/src/filters/component_transfer.rs | 25 +++--
rsvg_internals/src/filters/composite.rs | 18 +--
rsvg_internals/src/filters/context.rs | 6 +-
rsvg_internals/src/filters/convolve_matrix.rs | 41 ++++---
rsvg_internals/src/filters/displacement_map.rs | 14 +--
rsvg_internals/src/filters/gaussian_blur.rs | 10 +-
rsvg_internals/src/filters/image.rs | 10 +-
rsvg_internals/src/filters/input.rs | 24 ++--
rsvg_internals/src/filters/light/light_source.rs | 28 ++---
rsvg_internals/src/filters/light/lighting.rs | 83 +++++++-------
rsvg_internals/src/filters/merge.rs | 4 +-
rsvg_internals/src/filters/mod.rs | 16 +--
rsvg_internals/src/filters/morphology.rs | 20 ++--
rsvg_internals/src/filters/offset.rs | 6 +-
rsvg_internals/src/filters/turbulence.rs | 31 +++---
rsvg_internals/src/font_props.rs | 72 ++++++------
rsvg_internals/src/gradient.rs | 122 +++++++++++++--------
rsvg_internals/src/handle.rs | 14 ++-
rsvg_internals/src/image.rs | 12 +-
rsvg_internals/src/io.rs | 18 +--
rsvg_internals/src/iri.rs | 22 ++--
rsvg_internals/src/length.rs | 36 +++---
rsvg_internals/src/lib.rs | 7 +-
rsvg_internals/src/marker.rs | 76 ++++++-------
rsvg_internals/src/mask.rs | 22 ++--
rsvg_internals/src/node.rs | 4 +-
rsvg_internals/src/number_list.rs | 45 ++++----
rsvg_internals/src/paint_server.rs | 32 +++---
rsvg_internals/src/parsers.rs | 131 +++++++++++-----------
rsvg_internals/src/pattern.rs | 26 ++---
rsvg_internals/src/properties.rs | 131 +++++++++++-----------
rsvg_internals/src/property_bag.rs | 37 ++++---
rsvg_internals/src/property_defs.rs | 88 +++++++--------
rsvg_internals/src/property_macros.rs | 39 ++-----
rsvg_internals/src/shapes.rs | 133 +++++++++++------------
rsvg_internals/src/structure.rs | 41 +++----
rsvg_internals/src/style.rs | 8 +-
rsvg_internals/src/text.rs | 18 +--
rsvg_internals/src/transform.rs | 40 ++++---
rsvg_internals/src/unit_interval.rs | 26 ++---
rsvg_internals/src/viewbox.rs | 29 ++---
rsvg_internals/src/xml.rs | 19 +++-
57 files changed, 955 insertions(+), 956 deletions(-)
---
diff --git a/rsvg_internals/src/angle.rs b/rsvg_internals/src/angle.rs
index 86ecbd13..436bdf79 100644
--- a/rsvg_internals/src/angle.rs
+++ b/rsvg_internals/src/angle.rs
@@ -5,7 +5,7 @@ use std::f64::consts::*;
use cssparser::{Parser, Token};
use crate::error::*;
-use crate::parsers::{finite_f32, ParseToParseError};
+use crate::parsers::{finite_f32, Parse};
#[derive(Debug, Copy, Clone, PartialEq)]
pub struct Angle(f64);
@@ -61,8 +61,8 @@ impl Angle {
//
// angle ::= number ("deg" | "grad" | "rad")?
//
-impl ParseToParseError for Angle {
- fn parse_to_parse_error<'i>(parser: &mut Parser<'i, '_>) -> Result<Angle, CssParseError<'i>> {
+impl Parse for Angle {
+ fn parse<'i>(parser: &mut Parser<'i, '_>) -> Result<Angle, CssParseError<'i>> {
let angle = {
let loc = parser.current_source_location();
@@ -107,18 +107,18 @@ mod tests {
#[test]
fn parses_angle() {
- 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("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("-400grad"),
+ Angle::parse_str("-400grad"),
Ok(Angle::from_degrees(-360.0))
);
- 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());
+ assert!(Angle::parse_str("").is_err());
+ assert!(Angle::parse_str("foo").is_err());
+ assert!(Angle::parse_str("300foo").is_err());
}
fn test_bisection_angle(
diff --git a/rsvg_internals/src/aspect_ratio.rs b/rsvg_internals/src/aspect_ratio.rs
index 7568a0d5..eb07d6ca 100644
--- a/rsvg_internals/src/aspect_ratio.rs
+++ b/rsvg_internals/src/aspect_ratio.rs
@@ -25,7 +25,7 @@ use std::ops::Deref;
use cairo;
use crate::error::*;
-use crate::parsers::ParseToParseError;
+use crate::parsers::Parse;
use crate::rect::Rect;
use crate::viewbox::ViewBox;
use cssparser::{BasicParseError, Parser};
@@ -221,17 +221,15 @@ fn parse_fit_mode<'i>(parser: &mut Parser<'i, '_>) -> Result<FitMode, BasicParse
)
}
-impl ParseToParseError for AspectRatio {
- fn parse_to_parse_error<'i>(parser: &mut Parser<'i, '_>) -> Result<AspectRatio, CssParseError<'i>> {
+impl Parse for AspectRatio {
+ fn parse<'i>(parser: &mut Parser<'i, '_>) -> Result<AspectRatio, CssParseError<'i>> {
let defer = parser
.try_parse(|p| p.expect_ident_matching("defer"))
.is_ok();
let align_xy = parser.try_parse(|p| parse_align_xy(p))?;
- let fit = parser
- .try_parse(|p| parse_fit_mode(p))
- .unwrap_or_default();
+ let fit = parser.try_parse(|p| parse_fit_mode(p)).unwrap_or_default();
parser.expect_exhausted()?;
@@ -248,18 +246,18 @@ mod tests {
#[test]
fn parsing_invalid_strings_yields_error() {
- assert!(AspectRatio::parse_str_to_parse_error("").is_err());
- assert!(AspectRatio::parse_str_to_parse_error("defer").is_err());
- assert!(AspectRatio::parse_str_to_parse_error("defer foo").is_err());
- assert!(AspectRatio::parse_str_to_parse_error("defer xMidYMid foo").is_err());
- assert!(AspectRatio::parse_str_to_parse_error("xMidYMid foo").is_err());
- assert!(AspectRatio::parse_str_to_parse_error("defer xMidYMid meet foo").is_err());
+ assert!(AspectRatio::parse_str("").is_err());
+ assert!(AspectRatio::parse_str("defer").is_err());
+ assert!(AspectRatio::parse_str("defer foo").is_err());
+ assert!(AspectRatio::parse_str("defer xMidYMid foo").is_err());
+ assert!(AspectRatio::parse_str("xMidYMid foo").is_err());
+ assert!(AspectRatio::parse_str("defer xMidYMid meet foo").is_err());
}
#[test]
fn parses_valid_strings() {
assert_eq!(
- AspectRatio::parse_str_to_parse_error("defer none"),
+ AspectRatio::parse_str("defer none"),
Ok(AspectRatio {
defer: true,
align: None,
@@ -267,7 +265,7 @@ mod tests {
);
assert_eq!(
- AspectRatio::parse_str_to_parse_error("xMidYMid"),
+ AspectRatio::parse_str("xMidYMid"),
Ok(AspectRatio {
defer: false,
align: Some(Align {
@@ -279,7 +277,7 @@ mod tests {
);
assert_eq!(
- AspectRatio::parse_str_to_parse_error("defer xMidYMid"),
+ AspectRatio::parse_str("defer xMidYMid"),
Ok(AspectRatio {
defer: true,
align: Some(Align {
@@ -291,7 +289,7 @@ mod tests {
);
assert_eq!(
- AspectRatio::parse_str_to_parse_error("defer xMinYMax"),
+ AspectRatio::parse_str("defer xMinYMax"),
Ok(AspectRatio {
defer: true,
align: Some(Align {
@@ -303,7 +301,7 @@ mod tests {
);
assert_eq!(
- AspectRatio::parse_str_to_parse_error("defer xMaxYMid meet"),
+ AspectRatio::parse_str("defer xMaxYMid meet"),
Ok(AspectRatio {
defer: true,
align: Some(Align {
@@ -315,7 +313,7 @@ mod tests {
);
assert_eq!(
- AspectRatio::parse_str_to_parse_error("defer xMinYMax slice"),
+ AspectRatio::parse_str("defer xMinYMax slice"),
Ok(AspectRatio {
defer: true,
align: Some(Align {
@@ -338,75 +336,75 @@ mod tests {
fn aligns() {
let viewbox = ViewBox(Rect::from_size(1.0, 10.0));
- let foo = AspectRatio::parse_str_to_parse_error("xMinYMin meet").unwrap();
+ let foo = AspectRatio::parse_str("xMinYMin meet").unwrap();
let foo = foo.compute(&viewbox, &Rect::from_size(10.0, 1.0));
assert_rect_equal(&foo, &Rect::from_size(0.1, 1.0));
- let foo = AspectRatio::parse_str_to_parse_error("xMinYMin slice").unwrap();
+ let foo = AspectRatio::parse_str("xMinYMin slice").unwrap();
let foo = foo.compute(&viewbox, &Rect::from_size(10.0, 1.0));
assert_rect_equal(&foo, &Rect::from_size(10.0, 100.0));
- let foo = AspectRatio::parse_str_to_parse_error("xMinYMid meet").unwrap();
+ let foo = AspectRatio::parse_str("xMinYMid meet").unwrap();
let foo = foo.compute(&viewbox, &Rect::from_size(10.0, 1.0));
assert_rect_equal(&foo, &Rect::from_size(0.1, 1.0));
- let foo = AspectRatio::parse_str_to_parse_error("xMinYMid slice").unwrap();
+ let foo = AspectRatio::parse_str("xMinYMid slice").unwrap();
let foo = foo.compute(&viewbox, &Rect::from_size(10.0, 1.0));
assert_rect_equal(&foo, &Rect::new(0.0, -49.5, 10.0, 100.0 - 49.5));
- let foo = AspectRatio::parse_str_to_parse_error("xMinYMax meet").unwrap();
+ let foo = AspectRatio::parse_str("xMinYMax meet").unwrap();
let foo = foo.compute(&viewbox, &Rect::from_size(10.0, 1.0));
assert_rect_equal(&foo, &Rect::from_size(0.1, 1.0));
- let foo = AspectRatio::parse_str_to_parse_error("xMinYMax slice").unwrap();
+ let foo = AspectRatio::parse_str("xMinYMax slice").unwrap();
let foo = foo.compute(&viewbox, &Rect::from_size(10.0, 1.0));
assert_rect_equal(&foo, &Rect::new(0.0, -99.0, 10.0, 1.0));
- let foo = AspectRatio::parse_str_to_parse_error("xMidYMin meet").unwrap();
+ let foo = AspectRatio::parse_str("xMidYMin meet").unwrap();
let foo = foo.compute(&viewbox, &Rect::from_size(10.0, 1.0));
assert_rect_equal(&foo, &Rect::new(4.95, 0.0, 4.95 + 0.1, 1.0));
- let foo = AspectRatio::parse_str_to_parse_error("xMidYMin slice").unwrap();
+ let foo = AspectRatio::parse_str("xMidYMin slice").unwrap();
let foo = foo.compute(&viewbox, &Rect::from_size(10.0, 1.0));
assert_rect_equal(&foo, &Rect::from_size(10.0, 100.0));
- let foo = AspectRatio::parse_str_to_parse_error("xMidYMid meet").unwrap();
+ let foo = AspectRatio::parse_str("xMidYMid meet").unwrap();
let foo = foo.compute(&viewbox, &Rect::from_size(10.0, 1.0));
assert_rect_equal(&foo, &Rect::new(4.95, 0.0, 4.95 + 0.1, 1.0));
- let foo = AspectRatio::parse_str_to_parse_error("xMidYMid slice").unwrap();
+ let foo = AspectRatio::parse_str("xMidYMid slice").unwrap();
let foo = foo.compute(&viewbox, &Rect::from_size(10.0, 1.0));
assert_rect_equal(&foo, &Rect::new(0.0, -49.5, 10.0, 100.0 - 49.5));
- let foo = AspectRatio::parse_str_to_parse_error("xMidYMax meet").unwrap();
+ let foo = AspectRatio::parse_str("xMidYMax meet").unwrap();
let foo = foo.compute(&viewbox, &Rect::from_size(10.0, 1.0));
assert_rect_equal(&foo, &Rect::new(4.95, 0.0, 4.95 + 0.1, 1.0));
- let foo = AspectRatio::parse_str_to_parse_error("xMidYMax slice").unwrap();
+ let foo = AspectRatio::parse_str("xMidYMax slice").unwrap();
let foo = foo.compute(&viewbox, &Rect::from_size(10.0, 1.0));
assert_rect_equal(&foo, &Rect::new(0.0, -99.0, 10.0, 1.0));
- let foo = AspectRatio::parse_str_to_parse_error("xMaxYMin meet").unwrap();
+ let foo = AspectRatio::parse_str("xMaxYMin meet").unwrap();
let foo = foo.compute(&viewbox, &Rect::from_size(10.0, 1.0));
assert_rect_equal(&foo, &Rect::new(9.9, 0.0, 10.0, 1.0));
- let foo = AspectRatio::parse_str_to_parse_error("xMaxYMin slice").unwrap();
+ let foo = AspectRatio::parse_str("xMaxYMin slice").unwrap();
let foo = foo.compute(&viewbox, &Rect::from_size(10.0, 1.0));
assert_rect_equal(&foo, &Rect::from_size(10.0, 100.0));
- let foo = AspectRatio::parse_str_to_parse_error("xMaxYMid meet").unwrap();
+ let foo = AspectRatio::parse_str("xMaxYMid meet").unwrap();
let foo = foo.compute(&viewbox, &Rect::from_size(10.0, 1.0));
assert_rect_equal(&foo, &Rect::new(9.9, 0.0, 10.0, 1.0));
- let foo = AspectRatio::parse_str_to_parse_error("xMaxYMid slice").unwrap();
+ let foo = AspectRatio::parse_str("xMaxYMid slice").unwrap();
let foo = foo.compute(&viewbox, &Rect::from_size(10.0, 1.0));
assert_rect_equal(&foo, &Rect::new(0.0, -49.5, 10.0, 100.0 - 49.5));
- let foo = AspectRatio::parse_str_to_parse_error("xMaxYMax meet").unwrap();
+ let foo = AspectRatio::parse_str("xMaxYMax meet").unwrap();
let foo = foo.compute(&viewbox, &Rect::from_size(10.0, 1.0));
assert_rect_equal(&foo, &Rect::new(9.9, 0.0, 10.0, 1.0));
- let foo = AspectRatio::parse_str_to_parse_error("xMaxYMax slice").unwrap();
+ let foo = AspectRatio::parse_str("xMaxYMax slice").unwrap();
let foo = foo.compute(&viewbox, &Rect::from_size(10.0, 1.0));
assert_rect_equal(&foo, &Rect::new(0.0, -99.0, 10.0, 1.0));
}
diff --git a/rsvg_internals/src/clip_path.rs b/rsvg_internals/src/clip_path.rs
index 0e332d89..97a512cf 100644
--- a/rsvg_internals/src/clip_path.rs
+++ b/rsvg_internals/src/clip_path.rs
@@ -8,7 +8,7 @@ use crate::coord_units::CoordUnits;
use crate::drawing_ctx::DrawingCtx;
use crate::error::RenderingError;
use crate::node::{CascadedValues, NodeDraw, NodeResult, NodeTrait, RsvgNode};
-use crate::parsers::ParseValueToParseError;
+use crate::parsers::ParseValue;
use crate::property_bag::PropertyBag;
coord_units!(ClipPathUnits, CoordUnits::UserSpaceOnUse);
@@ -73,7 +73,7 @@ impl NodeTrait for ClipPath {
fn set_atts(&mut self, _: Option<&RsvgNode>, pbag: &PropertyBag<'_>) -> NodeResult {
for (attr, value) in pbag.iter() {
match attr.expanded() {
- expanded_name!(svg "clipPathUnits") => self.units = attr.parse_to_parse_error(value)?,
+ expanded_name!(svg "clipPathUnits") => self.units = attr.parse(value)?,
_ => (),
}
}
diff --git a/rsvg_internals/src/color.rs b/rsvg_internals/src/color.rs
index 45e914ff..b9c8e9f4 100644
--- a/rsvg_internals/src/color.rs
+++ b/rsvg_internals/src/color.rs
@@ -4,26 +4,22 @@ use cssparser::{self, Parser};
use libc;
use crate::error::*;
-use crate::parsers::ParseToParseError;
+use crate::parsers::Parse;
use crate::util::utf8_cstr;
pub use cssparser::Color;
-impl ParseToParseError for cssparser::Color {
- fn parse_to_parse_error<'i>(
- parser: &mut Parser<'i, '_>,
- ) -> Result<cssparser::Color, CssParseError<'i>> {
+impl Parse for cssparser::Color {
+ fn parse<'i>(parser: &mut Parser<'i, '_>) -> Result<cssparser::Color, CssParseError<'i>> {
Ok(cssparser::Color::parse(parser)?)
}
}
-impl ParseToParseError for cssparser::RGBA {
- fn parse_to_parse_error<'i>(
- parser: &mut Parser<'i, '_>,
- ) -> Result<cssparser::RGBA, CssParseError<'i>> {
+impl Parse for cssparser::RGBA {
+ fn parse<'i>(parser: &mut Parser<'i, '_>) -> Result<cssparser::RGBA, CssParseError<'i>> {
let loc = parser.current_source_location();
- match cssparser::Color::parse_to_parse_error(parser)? {
+ match cssparser::Color::parse(parser)? {
cssparser::Color::RGBA(rgba) => Ok(rgba),
cssparser::Color::CurrentColor => Err(loc.new_custom_error(ValueErrorKind::Value(
"currentColor is not allowed here".to_string(),
@@ -106,7 +102,7 @@ pub extern "C" fn rsvg_css_parse_color(string: *const libc::c_char) -> ColorSpec
argb: 0,
}
} else {
- ColorSpec::from(<Color as ParseToParseError>::parse_str_to_parse_error(s).map(Some))
+ ColorSpec::from(<Color as Parse>::parse_str(s).map(Some))
}
}
diff --git a/rsvg_internals/src/cond.rs b/rsvg_internals/src/cond.rs
index 231db0fb..25117c69 100644
--- a/rsvg_internals/src/cond.rs
+++ b/rsvg_internals/src/cond.rs
@@ -96,14 +96,14 @@ impl SystemLanguage {
if have_match {
Ok(SystemLanguage(have_match))
} else {
- locale_accepts_language_tag(locale, &language_tag)
- .map(SystemLanguage)
+ locale_accepts_language_tag(locale, &language_tag).map(SystemLanguage)
}
}
Err(e) => Err(ValueErrorKind::parse_error(&format!(
- "invalid language tag: \"{}\"", e)
- )),
+ "invalid language tag: \"{}\"",
+ e
+ ))),
},
)
}
diff --git a/rsvg_internals/src/coord_units.rs b/rsvg_internals/src/coord_units.rs
index 765f5d8f..febd6c77 100644
--- a/rsvg_internals/src/coord_units.rs
+++ b/rsvg_internals/src/coord_units.rs
@@ -3,7 +3,7 @@
use cssparser::Parser;
use crate::error::*;
-use crate::parsers::ParseToParseError;
+use crate::parsers::Parse;
/// Defines the units to be used for things that can consider a
/// coordinate system in terms of the current transformation, or in
@@ -14,8 +14,8 @@ pub enum CoordUnits {
ObjectBoundingBox,
}
-impl ParseToParseError for CoordUnits {
- fn parse_to_parse_error<'i>(parser: &mut Parser<'i, '_>) -> Result<Self, CssParseError<'i>> {
+impl Parse for CoordUnits {
+ fn parse<'i>(parser: &mut Parser<'i, '_>) -> Result<Self, CssParseError<'i>> {
Ok(parse_identifiers!(
parser,
"userSpaceOnUse" => CoordUnits::UserSpaceOnUse,
@@ -50,11 +50,11 @@ macro_rules! coord_units {
}
}
- impl $crate::parsers::ParseToParseError for $name {
- fn parse_to_parse_error<'i>(
+ impl $crate::parsers::Parse for $name {
+ fn parse<'i>(
parser: &mut ::cssparser::Parser<'i, '_>,
) -> Result<Self, $crate::error::CssParseError<'i>> {
- Ok($name($crate::coord_units::CoordUnits::parse_to_parse_error(parser)?))
+ Ok($name($crate::coord_units::CoordUnits::parse(parser)?))
}
}
};
@@ -68,18 +68,18 @@ mod tests {
#[test]
fn parsing_invalid_strings_yields_error() {
- assert!(MyUnits::parse_str_to_parse_error("").is_err());
- assert!(MyUnits::parse_str_to_parse_error("foo").is_err());
+ assert!(MyUnits::parse_str("").is_err());
+ assert!(MyUnits::parse_str("foo").is_err());
}
#[test]
fn parses_paint_server_units() {
assert_eq!(
- MyUnits::parse_str_to_parse_error("userSpaceOnUse"),
+ MyUnits::parse_str("userSpaceOnUse"),
Ok(MyUnits(CoordUnits::UserSpaceOnUse))
);
assert_eq!(
- MyUnits::parse_str_to_parse_error("objectBoundingBox"),
+ MyUnits::parse_str("objectBoundingBox"),
Ok(MyUnits(CoordUnits::ObjectBoundingBox))
);
}
diff --git a/rsvg_internals/src/create_node.rs b/rsvg_internals/src/create_node.rs
index b8aaf1d9..9e194bb5 100644
--- a/rsvg_internals/src/create_node.rs
+++ b/rsvg_internals/src/create_node.rs
@@ -22,8 +22,11 @@ use crate::filters::{
gaussian_blur::FeGaussianBlur,
image::FeImage,
light::{
- light_source::FeDistantLight, light_source::FePointLight, light_source::FeSpotLight,
- lighting::FeDiffuseLighting, lighting::FeSpecularLighting,
+ light_source::FeDistantLight,
+ light_source::FePointLight,
+ light_source::FeSpotLight,
+ lighting::FeDiffuseLighting,
+ lighting::FeSpecularLighting,
},
merge::{FeMerge, FeMergeNode},
morphology::FeMorphology,
@@ -265,7 +268,7 @@ pub fn create_node(name: &QualName, pbag: &PropertyBag) -> RsvgNode {
class = None;
};
-// sizes::print_sizes();
+ // sizes::print_sizes();
create_fn(name, id, class)
}
@@ -279,12 +282,12 @@ mod sizes {
macro_rules! print_size {
($ty:ty) => {
println!("sizeof {}: {}", stringify!($ty), mem::size_of::<$ty>());
- }
+ };
}
pub fn print_sizes() {
- use std::mem;
use crate::properties::{ComputedValues, ParsedProperty, SpecifiedValues};
+ use std::mem;
print_size!(NodeData);
print_size!(SpecifiedValues);
diff --git a/rsvg_internals/src/css.rs b/rsvg_internals/src/css.rs
index 607f4dda..cdf9e205 100644
--- a/rsvg_internals/src/css.rs
+++ b/rsvg_internals/src/css.rs
@@ -13,7 +13,6 @@
//! }
//!
//! #baz { stroke-width: 42; }
-//!
//! ```
//! The example contains three **rules**, the first one is an **at-rule*,
//! the other two are **qualified rules**.
@@ -122,8 +121,8 @@ impl<'i> DeclarationParser<'i> for DeclParser {
input: &mut Parser<'i, 't>,
) -> Result<Declaration, CssParseError<'i>> {
let prop_name = QualName::new(None, ns!(svg), LocalName::from(name.as_ref()));
- let property =
- parse_property(&prop_name, input, true).map_err(|_|
input.new_custom_error(ValueErrorKind::parse_error("parse error")))?;
+ let property = parse_property(&prop_name, input, true)
+ .map_err(|_| input.new_custom_error(ValueErrorKind::parse_error("parse error")))?;
let important = input.try_parse(parse_important).is_ok();
@@ -265,8 +264,10 @@ impl<'i> AtRuleParser<'i> for RuleParser {
&mut self,
name: CowRcStr<'i>,
input: &mut Parser<'i, 't>,
- ) -> Result<AtRuleType<Self::PreludeNoBlock, Self::PreludeBlock>, cssparser::ParseError<'i, Self::Error>>
- {
+ ) -> Result<
+ AtRuleType<Self::PreludeNoBlock, Self::PreludeBlock>,
+ cssparser::ParseError<'i, Self::Error>,
+ > {
match_ignore_ascii_case! { &name,
"import" => {
// FIXME: at the moment we ignore media queries
diff --git a/rsvg_internals/src/dasharray.rs b/rsvg_internals/src/dasharray.rs
index 4f83fc4a..1b31c269 100644
--- a/rsvg_internals/src/dasharray.rs
+++ b/rsvg_internals/src/dasharray.rs
@@ -4,7 +4,7 @@ use cssparser::Parser;
use crate::error::*;
use crate::length::*;
-use crate::parsers::{optional_comma, ParseToParseError};
+use crate::parsers::{optional_comma, Parse};
#[derive(Debug, PartialEq, Clone)]
pub enum Dasharray {
@@ -18,10 +18,8 @@ impl Default for Dasharray {
}
}
-impl ParseToParseError for Dasharray {
- fn parse_to_parse_error<'i>(
- parser: &mut Parser<'i, '_>,
- ) -> Result<Dasharray, CssParseError<'i>> {
+impl Parse for Dasharray {
+ fn parse<'i>(parser: &mut Parser<'i, '_>) -> Result<Dasharray, CssParseError<'i>> {
if parser
.try_parse(|p| p.expect_ident_matching("none"))
.is_ok()
@@ -34,7 +32,7 @@ impl ParseToParseError for Dasharray {
loop {
let loc = parser.current_source_location();
- let d = Length::<Both>::parse_to_parse_error(parser)?
+ let d = Length::<Both>::parse(parser)?
.check_nonnegative()
.map_err(|e| loc.new_custom_error(e))?;
dasharray.push(d);
@@ -57,7 +55,7 @@ mod tests {
#[test]
fn parses_dash_array() {
// helper to cut down boilderplate
- let length_parse = |s| Length::<Both>::parse_str_to_parse_error(s).unwrap();
+ let length_parse = |s| Length::<Both>::parse_str(s).unwrap();
let expected = Dasharray::Array(vec![
length_parse("1"),
@@ -91,53 +89,29 @@ mod tests {
let sample_6 = Dasharray::Array(vec![length_parse("5"), length_parse("3.14")]);
let sample_7 = Dasharray::Array(vec![length_parse("2")]);
- assert_eq!(
- Dasharray::parse_str_to_parse_error("none").unwrap(),
- Dasharray::None
- );
- assert_eq!(
- Dasharray::parse_str_to_parse_error("1 2in,3 4%").unwrap(),
- expected
- );
- assert_eq!(
- Dasharray::parse_str_to_parse_error("10,6").unwrap(),
- sample_1
- );
- assert_eq!(
- Dasharray::parse_str_to_parse_error("5,5,20").unwrap(),
- sample_2
- );
- assert_eq!(
- Dasharray::parse_str_to_parse_error("10px 20px 20px").unwrap(),
- sample_3
- );
- assert_eq!(
- Dasharray::parse_str_to_parse_error("25 5 , 5 5").unwrap(),
- sample_4
- );
- assert_eq!(
- Dasharray::parse_str_to_parse_error("3.1415926,8").unwrap(),
- sample_5
- );
- assert_eq!(
- Dasharray::parse_str_to_parse_error("5, 3.14").unwrap(),
- sample_6
- );
- assert_eq!(Dasharray::parse_str_to_parse_error("2").unwrap(), sample_7);
+ assert_eq!(Dasharray::parse_str("none").unwrap(), Dasharray::None);
+ assert_eq!(Dasharray::parse_str("1 2in,3 4%").unwrap(), expected);
+ assert_eq!(Dasharray::parse_str("10,6").unwrap(), sample_1);
+ assert_eq!(Dasharray::parse_str("5,5,20").unwrap(), sample_2);
+ assert_eq!(Dasharray::parse_str("10px 20px 20px").unwrap(), sample_3);
+ assert_eq!(Dasharray::parse_str("25 5 , 5 5").unwrap(), sample_4);
+ assert_eq!(Dasharray::parse_str("3.1415926,8").unwrap(), sample_5);
+ assert_eq!(Dasharray::parse_str("5, 3.14").unwrap(), sample_6);
+ assert_eq!(Dasharray::parse_str("2").unwrap(), sample_7);
// Negative numbers
- assert!(Dasharray::parse_str_to_parse_error("20,40,-20").is_err());
+ assert!(Dasharray::parse_str("20,40,-20").is_err());
// Empty dash_array
- assert!(Dasharray::parse_str_to_parse_error("").is_err());
- assert!(Dasharray::parse_str_to_parse_error("\t \n ").is_err());
- assert!(Dasharray::parse_str_to_parse_error(",,,").is_err());
- assert!(Dasharray::parse_str_to_parse_error("10, \t, 20 \n").is_err());
+ assert!(Dasharray::parse_str("").is_err());
+ assert!(Dasharray::parse_str("\t \n ").is_err());
+ assert!(Dasharray::parse_str(",,,").is_err());
+ assert!(Dasharray::parse_str("10, \t, 20 \n").is_err());
// No trailing commas allowed, parse error
- assert!(Dasharray::parse_str_to_parse_error("10,").is_err());
+ assert!(Dasharray::parse_str("10,").is_err());
// A comma should be followed by a number
- assert!(Dasharray::parse_str_to_parse_error("20,,10").is_err());
+ assert!(Dasharray::parse_str("20,,10").is_err());
}
}
diff --git a/rsvg_internals/src/document.rs b/rsvg_internals/src/document.rs
index cd893e7b..97bf7d09 100644
--- a/rsvg_internals/src/document.rs
+++ b/rsvg_internals/src/document.rs
@@ -32,7 +32,6 @@ pub struct Document {
// The following two require interior mutability because we load the extern
// resources all over the place. Eventually we'll be able to do this
// once, at loading time, and keep this immutable.
-
/// SVG documents referenced from this document.
externs: RefCell<Resources>,
diff --git a/rsvg_internals/src/drawing_ctx.rs b/rsvg_internals/src/drawing_ctx.rs
index 50737b06..4e8eac81 100644
--- a/rsvg_internals/src/drawing_ctx.rs
+++ b/rsvg_internals/src/drawing_ctx.rs
@@ -23,7 +23,12 @@ use crate::paint_server::{PaintServer, PaintSource};
use crate::pattern::Pattern;
use crate::properties::ComputedValues;
use crate::property_defs::{
- ClipRule, FillRule, ShapeRendering, StrokeDasharray, StrokeLinecap, StrokeLinejoin,
+ ClipRule,
+ FillRule,
+ ShapeRendering,
+ StrokeDasharray,
+ StrokeLinecap,
+ StrokeLinejoin,
};
use crate::rect::Rect;
use crate::surface_utils::shared_surface::SharedImageSurface;
@@ -1070,8 +1075,8 @@ impl AcquiredNodes {
// Maybe we should have the following stages:
// - load main SVG XML
//
- // - load secondary SVG XML and other files like images;
- // all document::Resources and document::Images loaded
+ // - load secondary SVG XML and other files like images; all document::Resources and
+ // document::Images loaded
//
// - Now that all files are loaded, resolve URL references
AcquireError::LinkNotFound(fragment.clone())
diff --git a/rsvg_internals/src/error.rs b/rsvg_internals/src/error.rs
index c831c153..1f01ed5d 100644
--- a/rsvg_internals/src/error.rs
+++ b/rsvg_internals/src/error.rs
@@ -34,7 +34,7 @@ impl<'i> From<CssParseError<'i>> for ParseError<'i> {
}
impl<'i> From<ValueErrorKind> for ParseError<'i> {
- fn from (v: ValueErrorKind) -> ParseError<'i> {
+ fn from(v: ValueErrorKind) -> ParseError<'i> {
ParseError::V(v)
}
}
@@ -219,16 +219,16 @@ impl<'i, O> AttributeResultExt<O> for Result<O, CssParseError<'i>> {
attr,
err: ValueErrorKind::Parse(s),
}
- },
+ }
ParseErrorKind::Basic(BasicParseErrorKind::EndOfInput) => NodeError {
attr,
err: ValueErrorKind::parse_error("unexpected end of input"),
},
- ParseErrorKind::Basic(_) => unreachable!(
- "attribute parsers should not return errors for CSS rules"
- ),
+ ParseErrorKind::Basic(_) => {
+ unreachable!("attribute parsers should not return errors for CSS rules")
+ }
ParseErrorKind::Custom(err) => NodeError { attr, err },
}
diff --git a/rsvg_internals/src/filter.rs b/rsvg_internals/src/filter.rs
index c99669c5..16e813e7 100644
--- a/rsvg_internals/src/filter.rs
+++ b/rsvg_internals/src/filter.rs
@@ -9,7 +9,7 @@ use crate::drawing_ctx::DrawingCtx;
use crate::error::ValueErrorKind;
use crate::length::*;
use crate::node::{NodeResult, NodeTrait, RsvgNode};
-use crate::parsers::{ParseToParseError, ParseValueToParseError};
+use crate::parsers::{Parse, ParseValue};
use crate::properties::ComputedValues;
use crate::property_bag::PropertyBag;
use crate::rect::Rect;
@@ -28,10 +28,10 @@ impl Default for Filter {
/// Constructs a new `Filter` with default properties.
fn default() -> Self {
Self {
- x: Length::<Horizontal>::parse_str_to_parse_error("-10%").unwrap(),
- y: Length::<Vertical>::parse_str_to_parse_error("-10%").unwrap(),
- width: Length::<Horizontal>::parse_str_to_parse_error("120%").unwrap(),
- height: Length::<Vertical>::parse_str_to_parse_error("120%").unwrap(),
+ x: Length::<Horizontal>::parse_str("-10%").unwrap(),
+ y: Length::<Vertical>::parse_str("-10%").unwrap(),
+ width: Length::<Horizontal>::parse_str("120%").unwrap(),
+ height: Length::<Vertical>::parse_str("120%").unwrap(),
filterunits: CoordUnits::ObjectBoundingBox,
primitiveunits: CoordUnits::UserSpaceOnUse,
}
@@ -115,7 +115,7 @@ impl NodeTrait for Filter {
// Parse filterUnits first as it affects x, y, width, height checks.
for (attr, value) in pbag.iter() {
match attr.expanded() {
- expanded_name!(svg "filterUnits") => self.filterunits = attr.parse_to_parse_error(value)?,
+ expanded_name!(svg "filterUnits") => self.filterunits = attr.parse(value)?,
_ => (),
}
}
@@ -161,25 +161,20 @@ impl NodeTrait for Filter {
for (attr, value) in pbag.iter() {
match attr.expanded() {
expanded_name!(svg "x") => {
- self.x =
- attr.parse_to_parse_error_and_validate(value, check_units_horizontal)?
+ self.x = attr.parse_and_validate(value, check_units_horizontal)?
}
expanded_name!(svg "y") => {
- self.y = attr.parse_to_parse_error_and_validate(value, check_units_vertical)?
+ self.y = attr.parse_and_validate(value, check_units_vertical)?
}
expanded_name!(svg "width") => {
- self.width = attr.parse_to_parse_error_and_validate(
- value,
- check_units_horizontal_and_ensure_nonnegative,
- )?
+ self.width = attr
+ .parse_and_validate(value, check_units_horizontal_and_ensure_nonnegative)?
}
expanded_name!(svg "height") => {
- self.height = attr.parse_to_parse_error_and_validate(
- value,
- check_units_vertical_and_ensure_nonnegative,
- )?
+ self.height =
+ attr.parse_and_validate(value, check_units_vertical_and_ensure_nonnegative)?
}
- expanded_name!(svg "primitiveUnits") => self.primitiveunits =
attr.parse_to_parse_error(value)?,
+ expanded_name!(svg "primitiveUnits") => self.primitiveunits = attr.parse(value)?,
_ => (),
}
}
diff --git a/rsvg_internals/src/filters/blend.rs b/rsvg_internals/src/filters/blend.rs
index 2c4f7f25..d084e166 100755
--- a/rsvg_internals/src/filters/blend.rs
+++ b/rsvg_internals/src/filters/blend.rs
@@ -5,7 +5,7 @@ use markup5ever::{expanded_name, local_name, namespace_url, ns};
use crate::drawing_ctx::DrawingCtx;
use crate::error::*;
use crate::node::{NodeResult, NodeTrait, RsvgNode};
-use crate::parsers::{ParseToParseError, ParseValueToParseError};
+use crate::parsers::{Parse, ParseValue};
use crate::property_bag::PropertyBag;
use crate::surface_utils::shared_surface::SharedImageSurface;
@@ -62,9 +62,9 @@ impl NodeTrait for FeBlend {
for (attr, value) in pbag.iter() {
match attr.expanded() {
expanded_name!(svg "in2") => {
- self.in2 = Some(attr.parse_to_parse_error(value)?);
+ self.in2 = Some(attr.parse(value)?);
}
- expanded_name!(svg "mode") => self.mode = attr.parse_to_parse_error(value)?,
+ expanded_name!(svg "mode") => self.mode = attr.parse(value)?,
_ => (),
}
}
@@ -133,8 +133,8 @@ impl FilterEffect for FeBlend {
}
}
-impl ParseToParseError for Mode {
- fn parse_to_parse_error<'i>(parser: &mut Parser<'i, '_>) -> Result<Self, CssParseError<'i>> {
+impl Parse for Mode {
+ fn parse<'i>(parser: &mut Parser<'i, '_>) -> Result<Self, CssParseError<'i>> {
Ok(parse_identifiers!(
parser,
"normal" => Mode::Normal,
diff --git a/rsvg_internals/src/filters/color_matrix.rs b/rsvg_internals/src/filters/color_matrix.rs
index d46ef424..8530f9f5 100644
--- a/rsvg_internals/src/filters/color_matrix.rs
+++ b/rsvg_internals/src/filters/color_matrix.rs
@@ -7,10 +7,13 @@ use crate::drawing_ctx::DrawingCtx;
use crate::error::*;
use crate::node::{NodeResult, NodeTrait, RsvgNode};
use crate::number_list::{NumberList, NumberListLength};
-use crate::parsers::{ParseToParseError, ParseValueToParseError};
+use crate::parsers::{Parse, ParseValue};
use crate::property_bag::PropertyBag;
use crate::surface_utils::{
- iterators::Pixels, shared_surface::SharedImageSurface, ImageSurfaceDataExt, Pixel,
+ iterators::Pixels,
+ shared_surface::SharedImageSurface,
+ ImageSurfaceDataExt,
+ Pixel,
};
use crate::util::clamp;
@@ -61,7 +64,7 @@ impl NodeTrait for FeColorMatrix {
.iter()
.filter(|(attr, _)| attr.expanded() == expanded_name!(svg "type"))
{
- operation_type = attr.parse_to_parse_error(value)?;
+ operation_type = attr.parse(value)?;
}
// Now read the matrix correspondingly.
@@ -85,25 +88,22 @@ impl NodeTrait for FeColorMatrix {
let new_matrix = match operation_type {
OperationType::LuminanceToAlpha => unreachable!(),
OperationType::Matrix => {
- let NumberList(v) = NumberList::parse_str_to_parse_error(
- value,
- NumberListLength::Exact(20),
- )
- .attribute(attr)?;
+ let NumberList(v) =
+ NumberList::parse_str(value, NumberListLength::Exact(20))
+ .attribute(attr)?;
let matrix = Matrix4x5::from_row_slice(&v);
let mut matrix = matrix.fixed_resize(0.0);
matrix[(4, 4)] = 1.0;
matrix
}
OperationType::Saturate => {
- let s: f64 = attr.parse_to_parse_error_and_validate(
- value,
- |s| if s < 0.0 || s > 1.0 {
+ let s: f64 = attr.parse_and_validate(value, |s| {
+ if s < 0.0 || s > 1.0 {
Err(ValueErrorKind::value_error("expected value from 0 to 1"))
} else {
Ok(s)
}
- )?;
+ })?;
#[cfg_attr(rustfmt, rustfmt_skip)]
Matrix5::new(
@@ -115,7 +115,7 @@ impl NodeTrait for FeColorMatrix {
)
}
OperationType::HueRotate => {
- let degrees: f64 = attr.parse_to_parse_error(value)?;
+ let degrees: f64 = attr.parse(value)?;
let (sin, cos) = degrees.to_radians().sin_cos();
#[cfg_attr(rustfmt, rustfmt_skip)]
@@ -227,8 +227,8 @@ impl FilterEffect for FeColorMatrix {
}
}
-impl ParseToParseError for OperationType {
- fn parse_to_parse_error<'i>(parser: &mut Parser<'i, '_>) -> Result<Self, CssParseError<'i>> {
+impl Parse for OperationType {
+ fn parse<'i>(parser: &mut Parser<'i, '_>) -> Result<Self, CssParseError<'i>> {
Ok(parse_identifiers!(
parser,
"matrix" => OperationType::Matrix,
diff --git a/rsvg_internals/src/filters/component_transfer.rs
b/rsvg_internals/src/filters/component_transfer.rs
index 7c73461a..94ff169f 100644
--- a/rsvg_internals/src/filters/component_transfer.rs
+++ b/rsvg_internals/src/filters/component_transfer.rs
@@ -8,10 +8,13 @@ use crate::drawing_ctx::DrawingCtx;
use crate::error::*;
use crate::node::{NodeResult, NodeTrait, NodeType, RsvgNode};
use crate::number_list::{NumberList, NumberListLength};
-use crate::parsers::{ParseToParseError, ParseValueToParseError};
+use crate::parsers::{Parse, ParseValue};
use crate::property_bag::PropertyBag;
use crate::surface_utils::{
- iterators::Pixels, shared_surface::SharedImageSurface, ImageSurfaceDataExt, Pixel,
+ iterators::Pixels,
+ shared_surface::SharedImageSurface,
+ ImageSurfaceDataExt,
+ Pixel,
};
use crate::util::clamp;
@@ -60,8 +63,8 @@ enum FunctionType {
Gamma,
}
-impl ParseToParseError for FunctionType {
- fn parse_to_parse_error<'i>(parser: &mut Parser<'i, '_>) -> Result<Self, CssParseError<'i>> {
+impl Parse for FunctionType {
+ fn parse<'i>(parser: &mut Parser<'i, '_>) -> Result<Self, CssParseError<'i>> {
Ok(parse_identifiers!(
parser,
"identity" => FunctionType::Identity,
@@ -208,19 +211,19 @@ macro_rules! func_x {
for (attr, value) in pbag.iter() {
match attr.expanded() {
expanded_name!(svg "type") => {
- self.function_type = attr.parse_to_parse_error(value)?
+ self.function_type = attr.parse(value)?
}
expanded_name!(svg "tableValues") => {
let NumberList(v) =
- NumberList::parse_str_to_parse_error(value, NumberListLength::Unbounded)
+ NumberList::parse_str(value, NumberListLength::Unbounded)
.attribute(attr)?;
self.table_values = v;
}
- expanded_name!(svg "slope") => self.slope = attr.parse_to_parse_error(value)?,
- expanded_name!(svg "intercept") => self.intercept =
attr.parse_to_parse_error(value)?,
- expanded_name!(svg "amplitude") => self.amplitude =
attr.parse_to_parse_error(value)?,
- expanded_name!(svg "exponent") => self.exponent = attr.parse_to_parse_error(value)?,
- expanded_name!(svg "offset") => self.offset = attr.parse_to_parse_error(value)?,
+ expanded_name!(svg "slope") => self.slope = attr.parse(value)?,
+ expanded_name!(svg "intercept") => self.intercept = attr.parse(value)?,
+ expanded_name!(svg "amplitude") => self.amplitude = attr.parse(value)?,
+ expanded_name!(svg "exponent") => self.exponent = attr.parse(value)?,
+ expanded_name!(svg "offset") => self.offset = attr.parse(value)?,
_ => (),
}
diff --git a/rsvg_internals/src/filters/composite.rs b/rsvg_internals/src/filters/composite.rs
index 13d649ac..da3bc3f1 100644
--- a/rsvg_internals/src/filters/composite.rs
+++ b/rsvg_internals/src/filters/composite.rs
@@ -5,7 +5,7 @@ use markup5ever::{expanded_name, local_name, namespace_url, ns};
use crate::drawing_ctx::DrawingCtx;
use crate::error::*;
use crate::node::{NodeResult, NodeTrait, RsvgNode};
-use crate::parsers::{ParseToParseError, ParseValueToParseError};
+use crate::parsers::{Parse, ParseValue};
use crate::property_bag::PropertyBag;
use crate::rect::IRect;
use crate::surface_utils::{
@@ -66,12 +66,12 @@ impl NodeTrait for FeComposite {
for (attr, value) in pbag.iter() {
match attr.expanded() {
- expanded_name!(svg "in2") => self.in2 = Some(attr.parse_to_parse_error(value)?),
- expanded_name!(svg "operator") => self.operator = attr.parse_to_parse_error(value)?,
- expanded_name!(svg "k1") => self.k1 = attr.parse_to_parse_error(value)?,
- expanded_name!(svg "k2") => self.k2 = attr.parse_to_parse_error(value)?,
- expanded_name!(svg "k3") => self.k3 = attr.parse_to_parse_error(value)?,
- expanded_name!(svg "k4") => self.k4 = attr.parse_to_parse_error(value)?,
+ expanded_name!(svg "in2") => self.in2 = Some(attr.parse(value)?),
+ expanded_name!(svg "operator") => self.operator = attr.parse(value)?,
+ expanded_name!(svg "k1") => self.k1 = attr.parse(value)?,
+ expanded_name!(svg "k2") => self.k2 = attr.parse(value)?,
+ expanded_name!(svg "k3") => self.k3 = attr.parse(value)?,
+ expanded_name!(svg "k4") => self.k4 = attr.parse(value)?,
_ => (),
}
}
@@ -211,8 +211,8 @@ impl FilterEffect for FeComposite {
}
}
-impl ParseToParseError for Operator {
- fn parse_to_parse_error<'i>(parser: &mut Parser<'i, '_>) -> Result<Self, CssParseError<'i>> {
+impl Parse for Operator {
+ fn parse<'i>(parser: &mut Parser<'i, '_>) -> Result<Self, CssParseError<'i>> {
Ok(parse_identifiers!(
parser,
"over" => Operator::Over,
diff --git a/rsvg_internals/src/filters/context.rs b/rsvg_internals/src/filters/context.rs
index af1459bc..f9d570ec 100644
--- a/rsvg_internals/src/filters/context.rs
+++ b/rsvg_internals/src/filters/context.rs
@@ -227,7 +227,11 @@ impl FilterContext {
);
// Return the only existing reference as immutable.
- bg.as_ref().unwrap().as_ref().map(|surf| surf.clone()).map_err(|&s| s)
+ bg.as_ref()
+ .unwrap()
+ .as_ref()
+ .map(|surf| surf.clone())
+ .map_err(|&s| s)
}
/// Returns the surface containing the background image snapshot alpha.
diff --git a/rsvg_internals/src/filters/convolve_matrix.rs b/rsvg_internals/src/filters/convolve_matrix.rs
index cd3af8a6..f49d00b6 100644
--- a/rsvg_internals/src/filters/convolve_matrix.rs
+++ b/rsvg_internals/src/filters/convolve_matrix.rs
@@ -7,13 +7,15 @@ use crate::drawing_ctx::DrawingCtx;
use crate::error::*;
use crate::node::{NodeResult, NodeTrait, RsvgNode};
use crate::number_list::{NumberList, NumberListLength};
-use crate::parsers::{NumberOptionalNumber, ParseToParseError, ParseValueToParseError};
+use crate::parsers::{NumberOptionalNumber, Parse, ParseValue};
use crate::property_bag::PropertyBag;
use crate::rect::IRect;
use crate::surface_utils::{
iterators::{PixelRectangle, Pixels},
shared_surface::SharedImageSurface,
- EdgeMode, ImageSurfaceDataExt, Pixel,
+ EdgeMode,
+ ImageSurfaceDataExt,
+ Pixel,
};
use crate::util::clamp;
@@ -62,20 +64,18 @@ impl NodeTrait for FeConvolveMatrix {
for (attr, value) in pbag.iter() {
match attr.expanded() {
expanded_name!(svg "order") => {
- let NumberOptionalNumber(x, y) = attr.parse_to_parse_error_and_validate(
- value,
- |v: NumberOptionalNumber<i32>| {
+ let NumberOptionalNumber(x, y) =
+ attr.parse_and_validate(value, |v: NumberOptionalNumber<i32>| {
if v.0 > 0 && v.1 > 0 {
Ok(v)
} else {
Err(ValueErrorKind::value_error("values must be greater than 0"))?
}
- },
- )?;
+ })?;
self.order = (x as u32, y as u32);
}
expanded_name!(svg "divisor") => {
- self.divisor = Some(attr.parse_to_parse_error_and_validate(value, |x| {
+ self.divisor = Some(attr.parse_and_validate(value, |x| {
if x != 0.0 {
Ok(x)
} else {
@@ -83,11 +83,11 @@ impl NodeTrait for FeConvolveMatrix {
}
})?)
}
- expanded_name!(svg "bias") => self.bias = attr.parse_to_parse_error(value)?,
- expanded_name!(svg "edgeMode") => self.edge_mode = attr.parse_to_parse_error(value)?,
+ expanded_name!(svg "bias") => self.bias = attr.parse(value)?,
+ expanded_name!(svg "edgeMode") => self.edge_mode = attr.parse(value)?,
expanded_name!(svg "kernelUnitLength") => {
let NumberOptionalNumber(x, y) =
- attr.parse_to_parse_error_and_validate(value, |v: NumberOptionalNumber<f64>| {
+ attr.parse_and_validate(value, |v: NumberOptionalNumber<f64>| {
if v.0 > 0.0 && v.1 > 0.0 {
Ok(v)
} else {
@@ -99,7 +99,7 @@ impl NodeTrait for FeConvolveMatrix {
self.kernel_unit_length = Some((x, y))
}
- expanded_name!(svg "preserveAlpha") => self.preserve_alpha =
attr.parse_to_parse_error(value)?,
+ expanded_name!(svg "preserveAlpha") => self.preserve_alpha = attr.parse(value)?,
_ => (),
}
@@ -110,7 +110,7 @@ impl NodeTrait for FeConvolveMatrix {
match attr.expanded() {
expanded_name!(svg "targetX") => {
self.target_x = {
- let v = attr.parse_to_parse_error_and_validate(value, |v: i32| {
+ let v = attr.parse_and_validate(value, |v: i32| {
if v >= 0 && v < self.order.0 as i32 {
Ok(v)
} else {
@@ -124,7 +124,7 @@ impl NodeTrait for FeConvolveMatrix {
}
expanded_name!(svg "targetY") => {
self.target_y = {
- let v = attr.parse_to_parse_error_and_validate(value, |v: i32| {
+ let v = attr.parse_and_validate(value, |v: i32| {
if v >= 0 && v < self.order.1 as i32 {
Ok(v)
} else {
@@ -158,9 +158,8 @@ impl NodeTrait for FeConvolveMatrix {
// #352: Parse as an unbounded list rather than exact length to prevent aborts due
// to huge allocation attempts by underlying Vec::with_capacity().
- let NumberList(v) =
- NumberList::parse_str_to_parse_error(value, NumberListLength::Unbounded)
- .attribute(attr.clone())?;
+ let NumberList(v) = NumberList::parse_str(value, NumberListLength::Unbounded)
+ .attribute(attr.clone())?;
if v.len() != number_of_elements {
return Err(ValueErrorKind::value_error(&format!(
@@ -337,8 +336,8 @@ impl FilterEffect for FeConvolveMatrix {
}
}
-impl ParseToParseError for EdgeMode {
- fn parse_to_parse_error<'i>(parser: &mut Parser<'i, '_>) -> Result<Self, CssParseError<'i>> {
+impl Parse for EdgeMode {
+ fn parse<'i>(parser: &mut Parser<'i, '_>) -> Result<Self, CssParseError<'i>> {
Ok(parse_identifiers!(
parser,
"duplicate" => EdgeMode::Duplicate,
@@ -349,8 +348,8 @@ impl ParseToParseError for EdgeMode {
}
// Used for the preserveAlpha attribute
-impl ParseToParseError for bool {
- fn parse_to_parse_error<'i>(parser: &mut Parser<'i, '_>) -> Result<Self, CssParseError<'i>> {
+impl Parse for bool {
+ fn parse<'i>(parser: &mut Parser<'i, '_>) -> Result<Self, CssParseError<'i>> {
Ok(parse_identifiers!(
parser,
"false" => false,
diff --git a/rsvg_internals/src/filters/displacement_map.rs b/rsvg_internals/src/filters/displacement_map.rs
index a2ee071a..0cf9725b 100644
--- a/rsvg_internals/src/filters/displacement_map.rs
+++ b/rsvg_internals/src/filters/displacement_map.rs
@@ -5,7 +5,7 @@ use markup5ever::{expanded_name, local_name, namespace_url, ns};
use crate::drawing_ctx::DrawingCtx;
use crate::error::*;
use crate::node::{NodeResult, NodeTrait, RsvgNode};
-use crate::parsers::{ParseToParseError, ParseValueToParseError};
+use crate::parsers::{Parse, ParseValue};
use crate::property_bag::PropertyBag;
use crate::surface_utils::{iterators::Pixels, shared_surface::SharedImageSurface};
@@ -52,15 +52,15 @@ impl NodeTrait for FeDisplacementMap {
for (attr, value) in pbag.iter() {
match attr.expanded() {
- expanded_name!(svg "in2") => self.in2 = Some(attr.parse_to_parse_error(value)?),
- expanded_name!(svg "scale") => self.scale = attr.parse_to_parse_error(value)?,
+ expanded_name!(svg "in2") => self.in2 = Some(attr.parse(value)?),
+ expanded_name!(svg "scale") => self.scale = attr.parse(value)?,
expanded_name!(svg "xChannelSelector") => {
- self.x_channel_selector = attr.parse_to_parse_error(value)?
+ self.x_channel_selector = attr.parse(value)?
}
expanded_name!(svg "yChannelSelector") => {
- self.y_channel_selector = attr.parse_to_parse_error(value)?
+ self.y_channel_selector = attr.parse(value)?
}
_ => (),
}
@@ -146,8 +146,8 @@ impl FilterEffect for FeDisplacementMap {
}
}
-impl ParseToParseError for ColorChannel {
- fn parse_to_parse_error<'i>(parser: &mut Parser<'i, '_>) -> Result<Self, CssParseError<'i>> {
+impl Parse for ColorChannel {
+ fn parse<'i>(parser: &mut Parser<'i, '_>) -> Result<Self, CssParseError<'i>> {
Ok(parse_identifiers!(
parser,
"R" => ColorChannel::R,
diff --git a/rsvg_internals/src/filters/gaussian_blur.rs b/rsvg_internals/src/filters/gaussian_blur.rs
index bd6f1464..751e7cad 100644
--- a/rsvg_internals/src/filters/gaussian_blur.rs
+++ b/rsvg_internals/src/filters/gaussian_blur.rs
@@ -7,7 +7,7 @@ use nalgebra::{DMatrix, Dynamic, VecStorage};
use crate::drawing_ctx::DrawingCtx;
use crate::error::*;
use crate::node::{NodeResult, NodeTrait, RsvgNode};
-use crate::parsers::{NumberOptionalNumber, ParseValueToParseError};
+use crate::parsers::{NumberOptionalNumber, ParseValue};
use crate::property_bag::PropertyBag;
use crate::rect::IRect;
use crate::surface_utils::{
@@ -49,16 +49,14 @@ impl NodeTrait for FeGaussianBlur {
for (attr, value) in pbag.iter() {
match attr.expanded() {
expanded_name!(svg "stdDeviation") => {
- let NumberOptionalNumber(x, y) = attr.parse_to_parse_error_and_validate(
- value,
- |v: NumberOptionalNumber<f64>| {
+ let NumberOptionalNumber(x, y) =
+ attr.parse_and_validate(value, |v: NumberOptionalNumber<f64>| {
if v.0 >= 0.0 && v.1 >= 0.0 {
Ok(v)
} else {
Err(ValueErrorKind::value_error("values can't be negative"))
}
- },
- )?;
+ })?;
self.std_deviation = (x, y);
}
diff --git a/rsvg_internals/src/filters/image.rs b/rsvg_internals/src/filters/image.rs
index af5ff42d..4f871bca 100644
--- a/rsvg_internals/src/filters/image.rs
+++ b/rsvg_internals/src/filters/image.rs
@@ -6,7 +6,7 @@ use crate::aspect_ratio::AspectRatio;
use crate::drawing_ctx::DrawingCtx;
use crate::error::*;
use crate::node::{CascadedValues, NodeResult, NodeTrait, RsvgNode};
-use crate::parsers::ParseValueToParseError;
+use crate::parsers::ParseValue;
use crate::property_bag::PropertyBag;
use crate::rect::Rect;
use crate::surface_utils::shared_surface::{SharedImageSurface, SurfaceType};
@@ -162,13 +162,13 @@ impl NodeTrait for FeImage {
for (attr, value) in pbag.iter() {
match attr.expanded() {
- expanded_name!(svg "preserveAspectRatio") => self.aspect = attr.parse_to_parse_error(value)?,
+ expanded_name!(svg "preserveAspectRatio") => self.aspect = attr.parse(value)?,
// "path" is used by some older Adobe Illustrator versions
expanded_name!(xlink "href") | expanded_name!(svg "path") => {
- let href = Href::parse(value).map_err(|_| {
- ValueErrorKind::parse_error("could not parse href")
- }).attribute(attr)?;
+ let href = Href::parse(value)
+ .map_err(|_| ValueErrorKind::parse_error("could not parse href"))
+ .attribute(attr)?;
self.href = Some(href);
}
diff --git a/rsvg_internals/src/filters/input.rs b/rsvg_internals/src/filters/input.rs
index 8d1302ef..2547edad 100644
--- a/rsvg_internals/src/filters/input.rs
+++ b/rsvg_internals/src/filters/input.rs
@@ -1,7 +1,7 @@
use cssparser::{BasicParseError, Parser, Token};
use crate::error::*;
-use crate::parsers::ParseToParseError;
+use crate::parsers::Parse;
/// An enumeration of possible inputs for a filter primitive.
#[derive(Debug, Clone, Eq, PartialEq, Hash)]
@@ -19,8 +19,8 @@ pub enum Input {
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct CustomIdent(String);
-impl ParseToParseError for Input {
- fn parse_to_parse_error<'i>(parser: &mut Parser<'i, '_>) -> Result<Self, CssParseError<'i>> {
+impl Parse for Input {
+ fn parse<'i>(parser: &mut Parser<'i, '_>) -> Result<Self, CssParseError<'i>> {
parser
.try_parse(|p| {
Ok(parse_identifiers!(
@@ -34,14 +34,14 @@ impl ParseToParseError for Input {
)?)
})
.or_else(|_: BasicParseError| {
- let ident = CustomIdent::parse_to_parse_error(parser)?;
+ let ident = CustomIdent::parse(parser)?;
Ok(Input::FilterOutput(ident))
})
}
}
-impl ParseToParseError for CustomIdent {
- fn parse_to_parse_error<'i>(parser: &mut Parser<'i, '_>) -> Result<Self, CssParseError<'i>> {
+impl Parse for CustomIdent {
+ fn parse<'i>(parser: &mut Parser<'i, '_>) -> Result<Self, CssParseError<'i>> {
let loc = parser.current_source_location();
let token = parser.next()?;
@@ -70,17 +70,17 @@ mod tests {
#[test]
fn parses_custom_ident() {
assert_eq!(
- CustomIdent::parse_str_to_parse_error("hello"),
+ CustomIdent::parse_str("hello"),
Ok(CustomIdent("hello".to_string()))
);
}
#[test]
fn invalid_custom_ident_yields_error() {
- assert!(CustomIdent::parse_str_to_parse_error("initial").is_err());
- assert!(CustomIdent::parse_str_to_parse_error("inherit").is_err());
- assert!(CustomIdent::parse_str_to_parse_error("unset").is_err());
- assert!(CustomIdent::parse_str_to_parse_error("default").is_err());
- assert!(CustomIdent::parse_str_to_parse_error("").is_err());
+ assert!(CustomIdent::parse_str("initial").is_err());
+ assert!(CustomIdent::parse_str("inherit").is_err());
+ assert!(CustomIdent::parse_str("unset").is_err());
+ assert!(CustomIdent::parse_str("default").is_err());
+ assert!(CustomIdent::parse_str("").is_err());
}
}
diff --git a/rsvg_internals/src/filters/light/light_source.rs
b/rsvg_internals/src/filters/light/light_source.rs
index 1f217b86..21991fcd 100644
--- a/rsvg_internals/src/filters/light/light_source.rs
+++ b/rsvg_internals/src/filters/light/light_source.rs
@@ -4,7 +4,7 @@ use nalgebra::Vector3;
use crate::filters::context::FilterContext;
use crate::node::{NodeResult, NodeTrait, RsvgNode};
-use crate::parsers::ParseValueToParseError;
+use crate::parsers::ParseValue;
use crate::property_bag::PropertyBag;
use crate::util::clamp;
@@ -106,8 +106,8 @@ impl NodeTrait for FeDistantLight {
fn set_atts(&mut self, _: Option<&RsvgNode>, pbag: &PropertyBag<'_>) -> NodeResult {
for (attr, value) in pbag.iter() {
match attr.expanded() {
- expanded_name!(svg "azimuth") => self.azimuth = attr.parse_to_parse_error(value)?,
- expanded_name!(svg "elevation") => self.elevation = attr.parse_to_parse_error(value)?,
+ expanded_name!(svg "azimuth") => self.azimuth = attr.parse(value)?,
+ expanded_name!(svg "elevation") => self.elevation = attr.parse(value)?,
_ => (),
}
}
@@ -138,9 +138,9 @@ impl NodeTrait for FePointLight {
fn set_atts(&mut self, _: Option<&RsvgNode>, pbag: &PropertyBag<'_>) -> NodeResult {
for (attr, value) in pbag.iter() {
match attr.expanded() {
- expanded_name!(svg "x") => self.x = attr.parse_to_parse_error(value)?,
- expanded_name!(svg "y") => self.y = attr.parse_to_parse_error(value)?,
- expanded_name!(svg "z") => self.z = attr.parse_to_parse_error(value)?,
+ expanded_name!(svg "x") => self.x = attr.parse(value)?,
+ expanded_name!(svg "y") => self.y = attr.parse(value)?,
+ expanded_name!(svg "z") => self.z = attr.parse(value)?,
_ => (),
}
}
@@ -187,19 +187,19 @@ impl NodeTrait for FeSpotLight {
fn set_atts(&mut self, _: Option<&RsvgNode>, pbag: &PropertyBag<'_>) -> NodeResult {
for (attr, value) in pbag.iter() {
match attr.expanded() {
- expanded_name!(svg "x") => self.x = attr.parse_to_parse_error(value)?,
- expanded_name!(svg "y") => self.y = attr.parse_to_parse_error(value)?,
- expanded_name!(svg "z") => self.z = attr.parse_to_parse_error(value)?,
- expanded_name!(svg "pointsAtX") => self.points_at_x = attr.parse_to_parse_error(value)?,
- expanded_name!(svg "pointsAtY") => self.points_at_y = attr.parse_to_parse_error(value)?,
- expanded_name!(svg "pointsAtZ") => self.points_at_z = attr.parse_to_parse_error(value)?,
+ expanded_name!(svg "x") => self.x = attr.parse(value)?,
+ expanded_name!(svg "y") => self.y = attr.parse(value)?,
+ expanded_name!(svg "z") => self.z = attr.parse(value)?,
+ expanded_name!(svg "pointsAtX") => self.points_at_x = attr.parse(value)?,
+ expanded_name!(svg "pointsAtY") => self.points_at_y = attr.parse(value)?,
+ expanded_name!(svg "pointsAtZ") => self.points_at_z = attr.parse(value)?,
expanded_name!(svg "specularExponent") => {
- self.specular_exponent = attr.parse_to_parse_error(value)?
+ self.specular_exponent = attr.parse(value)?
}
expanded_name!(svg "limitingConeAngle") => {
- self.limiting_cone_angle = Some(attr.parse_to_parse_error(value)?)
+ self.limiting_cone_angle = Some(attr.parse(value)?)
}
_ => (),
diff --git a/rsvg_internals/src/filters/light/lighting.rs b/rsvg_internals/src/filters/light/lighting.rs
index 321f4ac9..8dec0f32 100644
--- a/rsvg_internals/src/filters/light/lighting.rs
+++ b/rsvg_internals/src/filters/light/lighting.rs
@@ -12,19 +12,32 @@ use crate::error::*;
use crate::filters::{
context::{FilterContext, FilterOutput, FilterResult},
light::{
- bottom_left_normal, bottom_right_normal, bottom_row_normal, interior_normal,
- left_column_normal, light_source::FeDistantLight, light_source::FePointLight,
- light_source::FeSpotLight, light_source::LightSource, right_column_normal, top_left_normal,
- top_right_normal, top_row_normal, Normal,
+ bottom_left_normal,
+ bottom_right_normal,
+ bottom_row_normal,
+ interior_normal,
+ left_column_normal,
+ light_source::FeDistantLight,
+ light_source::FePointLight,
+ light_source::FeSpotLight,
+ light_source::LightSource,
+ right_column_normal,
+ top_left_normal,
+ top_right_normal,
+ top_row_normal,
+ Normal,
},
- FilterEffect, FilterError, PrimitiveWithInput,
+ FilterEffect,
+ FilterError,
+ PrimitiveWithInput,
};
use crate::node::{CascadedValues, NodeResult, NodeTrait, NodeType, RsvgNode};
-use crate::parsers::{NumberOptionalNumber, ParseValueToParseError};
+use crate::parsers::{NumberOptionalNumber, ParseValue};
use crate::property_bag::PropertyBag;
use crate::surface_utils::{
shared_surface::{SharedImageSurface, SurfaceType},
- ImageSurfaceDataExt, Pixel,
+ ImageSurfaceDataExt,
+ Pixel,
};
use crate::util::clamp;
@@ -54,14 +67,11 @@ impl Common {
for (attr, value) in pbag.iter() {
match attr.expanded() {
- expanded_name!(svg "surfaceScale") => {
- self.surface_scale = attr.parse_to_parse_error(value)?
- }
+ expanded_name!(svg "surfaceScale") => self.surface_scale = attr.parse(value)?,
expanded_name!(svg "kernelUnitLength") => {
- let NumberOptionalNumber(x, y) = attr.parse_to_parse_error_and_validate(
- value,
- |v: NumberOptionalNumber<f64>| {
+ let NumberOptionalNumber(x, y) =
+ attr.parse_and_validate(value, |v: NumberOptionalNumber<f64>| {
if v.0 > 0.0 && v.1 > 0.0 {
Ok(v)
} else {
@@ -69,8 +79,7 @@ impl Common {
"kernelUnitLength can't be less or equal to zero",
))
}
- },
- )?;
+ })?;
self.kernel_unit_length = Some((x, y));
}
@@ -106,7 +115,7 @@ impl NodeTrait for FeDiffuseLighting {
for (attr, value) in pbag.iter() {
match attr.expanded() {
expanded_name!(svg "diffuseConstant") => {
- self.diffuse_constant = attr.parse_to_parse_error_and_validate(value, |x| {
+ self.diffuse_constant = attr.parse_and_validate(value, |x| {
if x >= 0.0 {
Ok(x)
} else {
@@ -175,28 +184,26 @@ impl NodeTrait for FeSpecularLighting {
for (attr, value) in pbag.iter() {
match attr.expanded() {
expanded_name!(svg "specularConstant") => {
- self.specular_constant =
- attr.parse_to_parse_error_and_validate(value, |x| {
- if x >= 0.0 {
- Ok(x)
- } else {
- Err(ValueErrorKind::value_error(
- "specularConstant can't be negative",
- ))
- }
- })?;
+ self.specular_constant = attr.parse_and_validate(value, |x| {
+ if x >= 0.0 {
+ Ok(x)
+ } else {
+ Err(ValueErrorKind::value_error(
+ "specularConstant can't be negative",
+ ))
+ }
+ })?;
}
expanded_name!(svg "specularExponent") => {
- self.specular_exponent =
- attr.parse_to_parse_error_and_validate(value, |x| {
- if x >= 1.0 && x <= 128.0 {
- Ok(x)
- } else {
- Err(ValueErrorKind::value_error(
- "specularExponent should be between 1.0 and 128.0",
- ))
- }
- })?;
+ self.specular_exponent = attr.parse_and_validate(value, |x| {
+ if x >= 1.0 && x <= 128.0 {
+ Ok(x)
+ } else {
+ Err(ValueErrorKind::value_error(
+ "specularExponent should be between 1.0 and 128.0",
+ ))
+ }
+ })?;
}
_ => (),
}
@@ -294,8 +301,8 @@ macro_rules! impl_lighting_filter {
let (bounds_w, bounds_h) = bounds.size();
- // Check if the surface is too small for normal computation. This case is unspecified;
- // WebKit doesn't render anything in this case.
+ // Check if the surface is too small for normal computation. This case is
+ // unspecified; WebKit doesn't render anything in this case.
if bounds_w < 2 || bounds_h < 2 {
return Err(FilterError::LightingInputTooSmall);
}
diff --git a/rsvg_internals/src/filters/merge.rs b/rsvg_internals/src/filters/merge.rs
index 0f6d821e..eb47e735 100644
--- a/rsvg_internals/src/filters/merge.rs
+++ b/rsvg_internals/src/filters/merge.rs
@@ -3,7 +3,7 @@ use markup5ever::{expanded_name, local_name, namespace_url, ns};
use crate::drawing_ctx::DrawingCtx;
use crate::node::{NodeResult, NodeTrait, NodeType, RsvgNode};
-use crate::parsers::ParseValueToParseError;
+use crate::parsers::ParseValue;
use crate::property_bag::PropertyBag;
use crate::rect::IRect;
use crate::surface_utils::shared_surface::{SharedImageSurface, SurfaceType};
@@ -47,7 +47,7 @@ impl NodeTrait for FeMergeNode {
fn set_atts(&mut self, _parent: Option<&RsvgNode>, pbag: &PropertyBag<'_>) -> NodeResult {
for (attr, value) in pbag.iter() {
match attr.expanded() {
- expanded_name!(svg "in") => self.in_ = Some(attr.parse_to_parse_error(value)?),
+ expanded_name!(svg "in") => self.in_ = Some(attr.parse(value)?),
_ => (),
}
}
diff --git a/rsvg_internals/src/filters/mod.rs b/rsvg_internals/src/filters/mod.rs
index 71c8b638..ce6b5538 100644
--- a/rsvg_internals/src/filters/mod.rs
+++ b/rsvg_internals/src/filters/mod.rs
@@ -13,7 +13,7 @@ use crate::error::{RenderingError, ValueErrorKind};
use crate::filter::Filter;
use crate::length::*;
use crate::node::{CascadedValues, NodeResult, NodeTrait, NodeType, RsvgNode};
-use crate::parsers::ParseValueToParseError;
+use crate::parsers::ParseValue;
use crate::properties::ComputedValues;
use crate::property_bag::PropertyBag;
use crate::property_defs::ColorInterpolationFilters;
@@ -163,26 +163,26 @@ impl NodeTrait for Primitive {
for (attr, value) in pbag.iter() {
match attr.expanded() {
expanded_name!(svg "x") => {
- self.x = Some(attr.parse_to_parse_error_and_validate(value, check_units_horizontal)?)
+ self.x = Some(attr.parse_and_validate(value, check_units_horizontal)?)
}
expanded_name!(svg "y") => {
- self.y = Some(attr.parse_to_parse_error_and_validate(value, check_units_vertical)?)
+ self.y = Some(attr.parse_and_validate(value, check_units_vertical)?)
}
expanded_name!(svg "width") => {
self.width =
- Some(attr.parse_to_parse_error_and_validate(
+ Some(attr.parse_and_validate(
value,
check_units_horizontal_and_ensure_nonnegative,
)?)
}
expanded_name!(svg "height") => {
self.height =
- Some(attr.parse_to_parse_error_and_validate(
+ Some(attr.parse_and_validate(
value,
check_units_vertical_and_ensure_nonnegative,
)?)
}
- expanded_name!(svg "result") => self.result = Some(attr.parse_to_parse_error(value)?),
+ expanded_name!(svg "result") => self.result = Some(attr.parse(value)?),
_ => (),
}
}
@@ -218,7 +218,7 @@ impl NodeTrait for PrimitiveWithInput {
for (attr, value) in pbag.iter() {
match attr.expanded() {
- expanded_name!(svg "in") => self.in_ = Some(attr.parse_to_parse_error(value)?),
+ expanded_name!(svg "in") => self.in_ = Some(attr.parse(value)?),
_ => (),
}
}
@@ -350,7 +350,7 @@ pub fn render(
}
impl From<ColorInterpolationFilters> for SurfaceType {
- fn from(c: ColorInterpolationFilters) -> Self {
+ fn from(c: ColorInterpolationFilters) -> Self {
match c {
ColorInterpolationFilters::LinearRgb => SurfaceType::LinearRgb,
_ => SurfaceType::SRgb,
diff --git a/rsvg_internals/src/filters/morphology.rs b/rsvg_internals/src/filters/morphology.rs
index 2b33b70f..df69af05 100644
--- a/rsvg_internals/src/filters/morphology.rs
+++ b/rsvg_internals/src/filters/morphology.rs
@@ -7,13 +7,15 @@ use markup5ever::{expanded_name, local_name, namespace_url, ns};
use crate::drawing_ctx::DrawingCtx;
use crate::error::*;
use crate::node::{NodeResult, NodeTrait, RsvgNode};
-use crate::parsers::{NumberOptionalNumber, ParseToParseError, ParseValueToParseError};
+use crate::parsers::{NumberOptionalNumber, Parse, ParseValue};
use crate::property_bag::PropertyBag;
use crate::rect::IRect;
use crate::surface_utils::{
iterators::{PixelRectangle, Pixels},
shared_surface::SharedImageSurface,
- EdgeMode, ImageSurfaceDataExt, Pixel,
+ EdgeMode,
+ ImageSurfaceDataExt,
+ Pixel,
};
use super::context::{FilterContext, FilterOutput, FilterResult};
@@ -52,18 +54,16 @@ impl NodeTrait for FeMorphology {
for (attr, value) in pbag.iter() {
match attr.expanded() {
- expanded_name!(svg "operator") => self.operator = attr.parse_to_parse_error(value)?,
+ expanded_name!(svg "operator") => self.operator = attr.parse(value)?,
expanded_name!(svg "radius") => {
- let NumberOptionalNumber(x, y) = attr.parse_to_parse_error_and_validate(
- value,
- |v: NumberOptionalNumber<f64>| {
+ let NumberOptionalNumber(x, y) =
+ attr.parse_and_validate(value, |v: NumberOptionalNumber<f64>| {
if v.0 >= 0.0 && v.1 >= 0.0 {
Ok(v)
} else {
Err(ValueErrorKind::value_error("radius cannot be negative"))
}
- }
- )?;
+ })?;
self.radius = (x, y);
}
@@ -161,8 +161,8 @@ impl FilterEffect for FeMorphology {
}
}
-impl ParseToParseError for Operator {
- fn parse_to_parse_error<'i>(parser: &mut Parser<'i, '_>) -> Result<Self, CssParseError<'i>> {
+impl Parse for Operator {
+ fn parse<'i>(parser: &mut Parser<'i, '_>) -> Result<Self, CssParseError<'i>> {
Ok(parse_identifiers!(
parser,
"erode" => Operator::Erode,
diff --git a/rsvg_internals/src/filters/offset.rs b/rsvg_internals/src/filters/offset.rs
index 150b9008..6ef31dc6 100644
--- a/rsvg_internals/src/filters/offset.rs
+++ b/rsvg_internals/src/filters/offset.rs
@@ -3,7 +3,7 @@ use markup5ever::{expanded_name, local_name, namespace_url, ns};
use crate::drawing_ctx::DrawingCtx;
use crate::node::{NodeResult, NodeTrait, RsvgNode};
-use crate::parsers::ParseValueToParseError;
+use crate::parsers::ParseValue;
use crate::property_bag::PropertyBag;
use crate::surface_utils::shared_surface::SharedImageSurface;
@@ -37,8 +37,8 @@ impl NodeTrait for FeOffset {
for (attr, value) in pbag.iter() {
match attr.expanded() {
- expanded_name!(svg "dx") => self.dx = attr.parse_to_parse_error(value)?,
- expanded_name!(svg "dy") => self.dy = attr.parse_to_parse_error(value)?,
+ expanded_name!(svg "dx") => self.dx = attr.parse(value)?,
+ expanded_name!(svg "dy") => self.dy = attr.parse(value)?,
_ => (),
}
}
diff --git a/rsvg_internals/src/filters/turbulence.rs b/rsvg_internals/src/filters/turbulence.rs
index c81bc97b..c90d5d00 100644
--- a/rsvg_internals/src/filters/turbulence.rs
+++ b/rsvg_internals/src/filters/turbulence.rs
@@ -5,11 +5,12 @@ use markup5ever::{expanded_name, local_name, namespace_url, ns};
use crate::drawing_ctx::DrawingCtx;
use crate::error::*;
use crate::node::{CascadedValues, NodeResult, NodeTrait, RsvgNode};
-use crate::parsers::{NumberOptionalNumber, ParseToParseError, ParseValueToParseError};
+use crate::parsers::{NumberOptionalNumber, Parse, ParseValue};
use crate::property_bag::PropertyBag;
use crate::surface_utils::{
shared_surface::{SharedImageSurface, SurfaceType},
- ImageSurfaceDataExt, Pixel,
+ ImageSurfaceDataExt,
+ Pixel,
};
use crate::util::clamp;
@@ -65,35 +66,31 @@ impl NodeTrait for FeTurbulence {
for (attr, value) in pbag.iter() {
match attr.expanded() {
expanded_name!(svg "baseFrequency") => {
- let NumberOptionalNumber(x, y) = attr.parse_to_parse_error_and_validate(
- value,
- |v: NumberOptionalNumber<f64>| {
+ let NumberOptionalNumber(x, y) =
+ attr.parse_and_validate(value, |v: NumberOptionalNumber<f64>| {
if v.0 >= 0.0 && v.1 >= 0.0 {
Ok(v)
} else {
Err(ValueErrorKind::value_error("values can't be negative"))
}
- },
- )?;
+ })?;
self.base_frequency = (x, y);
}
expanded_name!(svg "numOctaves") => {
- self.num_octaves = attr.parse_to_parse_error(value)?;
+ self.num_octaves = attr.parse(value)?;
}
// Yes, seed needs to be parsed as a number and then truncated.
expanded_name!(svg "seed") => {
- let v: f64 = attr.parse_to_parse_error(value)?;
+ let v: f64 = attr.parse(value)?;
self.seed = clamp(
v.trunc(),
f64::from(i32::min_value()),
f64::from(i32::max_value()),
) as i32;
}
- expanded_name!(svg "stitchTiles") => {
- self.stitch_tiles = attr.parse_to_parse_error(value)?
- }
- expanded_name!(svg "type") => self.type_ = attr.parse_to_parse_error(value)?,
+ expanded_name!(svg "stitchTiles") => self.stitch_tiles = attr.parse(value)?,
+ expanded_name!(svg "type") => self.type_ = attr.parse(value)?,
_ => (),
}
}
@@ -422,8 +419,8 @@ impl FilterEffect for FeTurbulence {
}
}
-impl ParseToParseError for StitchTiles {
- fn parse_to_parse_error<'i>(parser: &mut Parser<'i, '_>) -> Result<Self, CssParseError<'i>> {
+impl Parse for StitchTiles {
+ fn parse<'i>(parser: &mut Parser<'i, '_>) -> Result<Self, CssParseError<'i>> {
Ok(parse_identifiers!(
parser,
"stitch" => StitchTiles::Stitch,
@@ -432,8 +429,8 @@ impl ParseToParseError for StitchTiles {
}
}
-impl ParseToParseError for NoiseType {
- fn parse_to_parse_error<'i>(parser: &mut Parser<'i, '_>) -> Result<Self, CssParseError<'i>> {
+impl Parse for NoiseType {
+ fn parse<'i>(parser: &mut Parser<'i, '_>) -> Result<Self, CssParseError<'i>> {
Ok(parse_identifiers!(
parser,
"fractalNoise" => NoiseType::FractalNoise,
diff --git a/rsvg_internals/src/font_props.rs b/rsvg_internals/src/font_props.rs
index b4be79ac..e8c9c94e 100644
--- a/rsvg_internals/src/font_props.rs
+++ b/rsvg_internals/src/font_props.rs
@@ -5,7 +5,7 @@ use cssparser::{BasicParseError, Parser};
use crate::drawing_ctx::ViewParams;
use crate::error::*;
use crate::length::*;
-use crate::parsers::ParseToParseError;
+use crate::parsers::Parse;
use crate::properties::ComputedValues;
// https://www.w3.org/TR/2008/REC-CSS2-20080411/fonts.html#propdef-font-size
@@ -60,12 +60,10 @@ impl FontSizeSpec {
}
}
-impl ParseToParseError for FontSizeSpec {
- fn parse_to_parse_error<'i>(
- parser: &mut Parser<'i, '_>,
- ) -> Result<FontSizeSpec, CssParseError<'i>> {
+impl Parse for FontSizeSpec {
+ fn parse<'i>(parser: &mut Parser<'i, '_>) -> Result<FontSizeSpec, CssParseError<'i>> {
parser
- .try_parse(|p| Length::<Both>::parse_to_parse_error(p))
+ .try_parse(|p| Length::<Both>::parse(p))
.and_then(|l| Ok(FontSizeSpec::Value(l)))
.or_else(|_| {
Ok(parse_identifiers!(
@@ -102,8 +100,8 @@ pub enum FontWeightSpec {
W900,
}
-impl ParseToParseError for FontWeightSpec {
- fn parse_to_parse_error<'i>(parser: &mut Parser<'i, '_>) -> Result<FontWeightSpec, CssParseError<'i>> {
+impl Parse for FontWeightSpec {
+ fn parse<'i>(parser: &mut Parser<'i, '_>) -> Result<FontWeightSpec, CssParseError<'i>> {
parser
.try_parse(|p| {
Ok(parse_identifiers!(
@@ -129,7 +127,7 @@ impl ParseToParseError for FontWeightSpec {
700 => Ok(FontWeightSpec::W700),
800 => Ok(FontWeightSpec::W800),
900 => Ok(FontWeightSpec::W900),
- _ => Err(loc.new_custom_error(ValueErrorKind::parse_error("parse error")))
+ _ => Err(loc.new_custom_error(ValueErrorKind::parse_error("parse error"))),
})
})
}
@@ -164,12 +162,10 @@ impl LetterSpacingSpec {
}
}
-impl ParseToParseError for LetterSpacingSpec {
- fn parse_to_parse_error<'i>(
- parser: &mut Parser<'i, '_>,
- ) -> Result<LetterSpacingSpec, CssParseError<'i>> {
+impl Parse for LetterSpacingSpec {
+ fn parse<'i>(parser: &mut Parser<'i, '_>) -> Result<LetterSpacingSpec, CssParseError<'i>> {
parser
- .try_parse(|p| Length::<Horizontal>::parse_to_parse_error(p))
+ .try_parse(|p| Length::<Horizontal>::parse(p))
.and_then(|l| Ok(LetterSpacingSpec::Value(l)))
.or_else(|_| {
Ok(parse_identifiers!(
@@ -184,10 +180,8 @@ impl ParseToParseError for LetterSpacingSpec {
#[derive(Debug, Clone, PartialEq)]
pub struct SingleFontFamily(pub String);
-impl ParseToParseError for SingleFontFamily {
- fn parse_to_parse_error<'i>(
- parser: &mut Parser<'i, '_>,
- ) -> Result<SingleFontFamily, CssParseError<'i>> {
+impl Parse for SingleFontFamily {
+ fn parse<'i>(parser: &mut Parser<'i, '_>) -> Result<SingleFontFamily, CssParseError<'i>> {
let loc = parser.current_source_location();
if let Ok(cow) = parser.try_parse(|p| p.expect_string_cloned()) {
@@ -219,41 +213,41 @@ mod tests {
#[test]
fn detects_invalid_invalid_font_size() {
- assert!(FontSizeSpec::parse_str_to_parse_error("furlong").is_err());
+ assert!(FontSizeSpec::parse_str("furlong").is_err());
}
#[test]
fn parses_font_weight() {
assert_eq!(
- <FontWeightSpec as ParseToParseError>::parse_str_to_parse_error("normal"),
+ <FontWeightSpec as Parse>::parse_str("normal"),
Ok(FontWeightSpec::Normal)
);
assert_eq!(
- <FontWeightSpec as ParseToParseError>::parse_str_to_parse_error("bold"),
+ <FontWeightSpec as Parse>::parse_str("bold"),
Ok(FontWeightSpec::Bold)
);
assert_eq!(
- <FontWeightSpec as ParseToParseError>::parse_str_to_parse_error("100"),
+ <FontWeightSpec as Parse>::parse_str("100"),
Ok(FontWeightSpec::W100)
);
}
#[test]
fn detects_invalid_font_weight() {
- assert!(<FontWeightSpec as ParseToParseError>::parse_str_to_parse_error("").is_err());
- assert!(<FontWeightSpec as ParseToParseError>::parse_str_to_parse_error("strange").is_err());
- assert!(<FontWeightSpec as ParseToParseError>::parse_str_to_parse_error("314").is_err());
- assert!(<FontWeightSpec as ParseToParseError>::parse_str_to_parse_error("3.14").is_err());
+ assert!(<FontWeightSpec as Parse>::parse_str("").is_err());
+ assert!(<FontWeightSpec as Parse>::parse_str("strange").is_err());
+ assert!(<FontWeightSpec as Parse>::parse_str("314").is_err());
+ assert!(<FontWeightSpec as Parse>::parse_str("3.14").is_err());
}
#[test]
fn parses_letter_spacing() {
assert_eq!(
- <LetterSpacingSpec as ParseToParseError>::parse_str_to_parse_error("normal"),
+ <LetterSpacingSpec as Parse>::parse_str("normal"),
Ok(LetterSpacingSpec::Normal)
);
assert_eq!(
- <LetterSpacingSpec as ParseToParseError>::parse_str_to_parse_error("10em"),
+ <LetterSpacingSpec as Parse>::parse_str("10em"),
Ok(LetterSpacingSpec::Value(Length::<Horizontal>::new(
10.0,
LengthUnit::Em,
@@ -264,16 +258,14 @@ mod tests {
#[test]
fn computes_letter_spacing() {
assert_eq!(
- <LetterSpacingSpec as ParseToParseError>::parse_str_to_parse_error("normal")
- .map(|s| s.compute()),
+ <LetterSpacingSpec as Parse>::parse_str("normal").map(|s| s.compute()),
Ok(LetterSpacingSpec::Value(Length::<Horizontal>::new(
0.0,
LengthUnit::Px,
)))
);
assert_eq!(
- <LetterSpacingSpec as ParseToParseError>::parse_str_to_parse_error("10em")
- .map(|s| s.compute()),
+ <LetterSpacingSpec as Parse>::parse_str("10em").map(|s| s.compute()),
Ok(LetterSpacingSpec::Value(Length::<Horizontal>::new(
10.0,
LengthUnit::Em,
@@ -283,36 +275,36 @@ mod tests {
#[test]
fn detects_invalid_invalid_letter_spacing() {
- assert!(LetterSpacingSpec::parse_str_to_parse_error("furlong").is_err());
+ assert!(LetterSpacingSpec::parse_str("furlong").is_err());
}
#[test]
fn parses_font_family() {
assert_eq!(
- <SingleFontFamily as ParseToParseError>::parse_str_to_parse_error("'Hello world'"),
+ <SingleFontFamily as Parse>::parse_str("'Hello world'"),
Ok(SingleFontFamily("Hello world".to_owned()))
);
assert_eq!(
- <SingleFontFamily as ParseToParseError>::parse_str_to_parse_error("\"Hello world\""),
+ <SingleFontFamily as Parse>::parse_str("\"Hello world\""),
Ok(SingleFontFamily("Hello world".to_owned()))
);
assert_eq!(
- <SingleFontFamily as ParseToParseError>::parse_str_to_parse_error(" Hello world "),
+ <SingleFontFamily as Parse>::parse_str(" Hello world "),
Ok(SingleFontFamily("Hello world".to_owned()))
);
assert_eq!(
- <SingleFontFamily as ParseToParseError>::parse_str_to_parse_error("Plonk"),
+ <SingleFontFamily as Parse>::parse_str("Plonk"),
Ok(SingleFontFamily("Plonk".to_owned()))
);
}
#[test]
fn detects_invalid_font_family() {
- assert!(<SingleFontFamily as ParseToParseError>::parse_str_to_parse_error("").is_err());
- assert!(<SingleFontFamily as ParseToParseError>::parse_str_to_parse_error("''").is_err());
- assert!(<SingleFontFamily as ParseToParseError>::parse_str_to_parse_error("42").is_err());
+ assert!(<SingleFontFamily as Parse>::parse_str("").is_err());
+ assert!(<SingleFontFamily as Parse>::parse_str("''").is_err());
+ assert!(<SingleFontFamily as Parse>::parse_str("42").is_err());
}
}
diff --git a/rsvg_internals/src/gradient.rs b/rsvg_internals/src/gradient.rs
index fcdcdcb6..5b2befcd 100644
--- a/rsvg_internals/src/gradient.rs
+++ b/rsvg_internals/src/gradient.rs
@@ -13,7 +13,7 @@ use crate::error::*;
use crate::length::*;
use crate::node::{CascadedValues, NodeResult, NodeTrait, NodeType, RsvgNode};
use crate::paint_server::{AsPaintSource, PaintSource};
-use crate::parsers::{ParseToParseError, ParseValueToParseError};
+use crate::parsers::{Parse, ParseValue};
use crate::properties::ComputedValues;
use crate::property_bag::PropertyBag;
use crate::property_defs::StopColor;
@@ -43,8 +43,8 @@ enum SpreadMethod {
Repeat,
}
-impl ParseToParseError for SpreadMethod {
- fn parse_to_parse_error<'i>(parser: &mut Parser<'i, '_>) -> Result<SpreadMethod, CssParseError<'i>> {
+impl Parse for SpreadMethod {
+ fn parse<'i>(parser: &mut Parser<'i, '_>) -> Result<SpreadMethod, CssParseError<'i>> {
Ok(parse_identifiers!(
parser,
"pad" => SpreadMethod::Pad,
@@ -114,9 +114,8 @@ fn fix_focus_point(fx: f64, fy: f64, cx: f64, cy: f64, radius: f64) -> (f64, f64
pub struct Stop {
/// <stop offset="..."/>
offset: UnitInterval,
-
- // stop-color and stop-opacity are not attributes; they are properties, so
- // they go into property_defs.rs
+ /* stop-color and stop-opacity are not attributes; they are properties, so
+ * they go into property_defs.rs */
}
fn validate_offset(length: Length<Both>) -> Result<Length<Both>, ValueErrorKind> {
@@ -134,7 +133,7 @@ impl NodeTrait for Stop {
match attr.expanded() {
expanded_name!(svg "offset") => {
self.offset = attr
- .parse_to_parse_error_and_validate(value, validate_offset)
+ .parse_and_validate(value, validate_offset)
.map(|l| UnitInterval::clamp(l.length))?
}
_ => (),
@@ -222,16 +221,31 @@ impl UnresolvedVariant {
fn resolve_from_fallback(&self, fallback: &UnresolvedVariant) -> UnresolvedVariant {
match (*self, *fallback) {
- (UnresolvedVariant::Linear { x1, y1, x2, y2 },
- UnresolvedVariant::Linear { x1: fx1, y1: fy1, x2: fx2, y2: fy2 }) => UnresolvedVariant::Linear {
+ (
+ UnresolvedVariant::Linear { x1, y1, x2, y2 },
+ UnresolvedVariant::Linear {
+ x1: fx1,
+ y1: fy1,
+ x2: fx2,
+ y2: fy2,
+ },
+ ) => UnresolvedVariant::Linear {
x1: x1.or(fx1),
y1: y1.or(fy1),
x2: x2.or(fx2),
y2: y2.or(fy2),
},
- (UnresolvedVariant::Radial { cx, cy, r, fx, fy },
- UnresolvedVariant::Radial { cx: fcx, cy: fcy, r: fr, fx: ffx, fy: ffy }) =>
UnresolvedVariant::Radial {
+ (
+ UnresolvedVariant::Radial { cx, cy, r, fx, fy },
+ UnresolvedVariant::Radial {
+ cx: fcx,
+ cy: fcy,
+ r: fr,
+ fx: ffx,
+ fy: ffy,
+ },
+ ) => UnresolvedVariant::Radial {
cx: cx.or(fcx),
cy: cy.or(fcy),
r: r.or(fr),
@@ -248,23 +262,23 @@ impl UnresolvedVariant {
fn resolve_from_defaults(&self) -> UnresolvedVariant {
match self {
UnresolvedVariant::Linear { x1, y1, x2, y2 } => UnresolvedVariant::Linear {
- x1: x1.or_else(|| Some(Length::<Horizontal>::parse_str_to_parse_error("0%").unwrap())),
- y1: y1.or_else(|| Some(Length::<Vertical>::parse_str_to_parse_error("0%").unwrap())),
- x2: x2.or_else(|| Some(Length::<Horizontal>::parse_str_to_parse_error("100%").unwrap())),
- y2: y2.or_else(|| Some(Length::<Vertical>::parse_str_to_parse_error("0%").unwrap())),
+ x1: x1.or_else(|| Some(Length::<Horizontal>::parse_str("0%").unwrap())),
+ y1: y1.or_else(|| Some(Length::<Vertical>::parse_str("0%").unwrap())),
+ x2: x2.or_else(|| Some(Length::<Horizontal>::parse_str("100%").unwrap())),
+ y2: y2.or_else(|| Some(Length::<Vertical>::parse_str("0%").unwrap())),
},
UnresolvedVariant::Radial { cx, cy, r, fx, fy } => {
- let cx = cx.or_else(|| Some(Length::<Horizontal>::parse_str_to_parse_error("50%").unwrap()));
- let cy = cy.or_else(|| Some(Length::<Vertical>::parse_str_to_parse_error("50%").unwrap()));
- let r = r.or_else(|| Some(Length::<Both>::parse_str_to_parse_error("50%").unwrap()));
+ let cx = cx.or_else(|| Some(Length::<Horizontal>::parse_str("50%").unwrap()));
+ let cy = cy.or_else(|| Some(Length::<Vertical>::parse_str("50%").unwrap()));
+ let r = r.or_else(|| Some(Length::<Both>::parse_str("50%").unwrap()));
// fx and fy fall back to the presentational value of cx and cy
let fx = fx.or(cx);
let fy = fy.or(cy);
UnresolvedVariant::Radial { cx, cy, r, fx, fy }
- },
+ }
}
}
}
@@ -472,7 +486,13 @@ impl UnresolvedGradient {
let stops = self.stops.clone().or_else(|| fallback.stops.clone());
let variant = self.variant.resolve_from_fallback(&fallback.variant);
- UnresolvedGradient { units, affine, spread, stops, variant }
+ UnresolvedGradient {
+ units,
+ affine,
+ spread,
+ stops,
+ variant,
+ }
}
fn resolve_from_defaults(&self) -> UnresolvedGradient {
@@ -482,7 +502,13 @@ impl UnresolvedGradient {
let stops = self.stops.clone().or_else(|| Some(Vec::<ColorStop>::new()));
let variant = self.variant.resolve_from_defaults();
- UnresolvedGradient { units, affine, spread, stops, variant }
+ UnresolvedGradient {
+ units,
+ affine,
+ spread,
+ stops,
+ variant,
+ }
}
}
@@ -539,7 +565,7 @@ macro_rules! impl_get_unresolved {
}
}
}
- }
+ };
}
impl_get_unresolved!(LinearGradient);
impl_get_unresolved!(RadialGradient);
@@ -548,9 +574,9 @@ impl Common {
fn set_atts(&mut self, pbag: &PropertyBag<'_>) -> NodeResult {
for (attr, value) in pbag.iter() {
match attr.expanded() {
- expanded_name!(svg "gradientUnits") => self.units = Some(attr.parse_to_parse_error(value)?),
- expanded_name!(svg "gradientTransform") => self.affine =
Some(attr.parse_to_parse_error(value)?),
- expanded_name!(svg "spreadMethod") => self.spread = Some(attr.parse_to_parse_error(value)?),
+ expanded_name!(svg "gradientUnits") => self.units = Some(attr.parse(value)?),
+ expanded_name!(svg "gradientTransform") => self.affine = Some(attr.parse(value)?),
+ expanded_name!(svg "spreadMethod") => self.spread = Some(attr.parse(value)?),
expanded_name!(xlink "href") => {
self.fallback = Some(Fragment::parse(value).attribute(attr)?)
}
@@ -568,10 +594,10 @@ impl NodeTrait for LinearGradient {
for (attr, value) in pbag.iter() {
match attr.expanded() {
- expanded_name!(svg "x1") => self.x1 = Some(attr.parse_to_parse_error(value)?),
- expanded_name!(svg "y1") => self.y1 = Some(attr.parse_to_parse_error(value)?),
- expanded_name!(svg "x2") => self.x2 = Some(attr.parse_to_parse_error(value)?),
- expanded_name!(svg "y2") => self.y2 = Some(attr.parse_to_parse_error(value)?),
+ expanded_name!(svg "x1") => self.x1 = Some(attr.parse(value)?),
+ expanded_name!(svg "y1") => self.y1 = Some(attr.parse(value)?),
+ expanded_name!(svg "x2") => self.x2 = Some(attr.parse(value)?),
+ expanded_name!(svg "y2") => self.y2 = Some(attr.parse(value)?),
_ => (),
}
@@ -587,11 +613,11 @@ impl NodeTrait for RadialGradient {
for (attr, value) in pbag.iter() {
match attr.expanded() {
- expanded_name!(svg "cx") => self.cx = Some(attr.parse_to_parse_error(value)?),
- expanded_name!(svg "cy") => self.cy = Some(attr.parse_to_parse_error(value)?),
- expanded_name!(svg "r") => self.r = Some(attr.parse_to_parse_error(value)?),
- expanded_name!(svg "fx") => self.fx = Some(attr.parse_to_parse_error(value)?),
- expanded_name!(svg "fy") => self.fy = Some(attr.parse_to_parse_error(value)?),
+ expanded_name!(svg "cx") => self.cx = Some(attr.parse(value)?),
+ expanded_name!(svg "cy") => self.cy = Some(attr.parse(value)?),
+ expanded_name!(svg "r") => self.r = Some(attr.parse(value)?),
+ expanded_name!(svg "fx") => self.fx = Some(attr.parse(value)?),
+ expanded_name!(svg "fy") => self.fy = Some(attr.parse(value)?),
_ => (),
}
@@ -616,7 +642,10 @@ macro_rules! impl_paint_source {
return Ok(gradient.clone());
}
- let Unresolved { mut gradient, mut fallback } = self.get_unresolved(node);
+ let Unresolved {
+ mut gradient,
+ mut fallback,
+ } = self.get_unresolved(node);
let mut stack = NodeStack::new();
@@ -641,7 +670,7 @@ macro_rules! impl_paint_source {
a_gradient.get_unresolved(&acquired_node)
}
- _ => unreachable!()
+ _ => unreachable!(),
};
gradient = gradient.resolve_from_fallback(&unresolved.gradient);
@@ -661,7 +690,7 @@ macro_rules! impl_paint_source {
Ok(gradient)
}
}
- }
+ };
}
impl_paint_source!(
@@ -769,25 +798,28 @@ fn acquire_gradient<'a>(
draw_ctx: &'a mut DrawingCtx,
fragment: &Fragment,
) -> Result<AcquiredNode, AcquireError> {
- draw_ctx.acquire_node(fragment, &[NodeType::LinearGradient, NodeType::RadialGradient])
+ draw_ctx.acquire_node(
+ fragment,
+ &[NodeType::LinearGradient, NodeType::RadialGradient],
+ )
}
#[cfg(test)]
mod tests {
use super::*;
- use markup5ever::{namespace_url, ns, QualName};
use crate::float_eq_cairo::ApproxEqCairo;
use crate::node::{NodeData, NodeType, RsvgNode};
+ use markup5ever::{namespace_url, ns, QualName};
#[test]
fn parses_spread_method() {
- assert_eq!(SpreadMethod::parse_str_to_parse_error("pad"), Ok(SpreadMethod::Pad));
+ assert_eq!(SpreadMethod::parse_str("pad"), Ok(SpreadMethod::Pad));
assert_eq!(
- SpreadMethod::parse_str_to_parse_error("reflect"),
+ SpreadMethod::parse_str("reflect"),
Ok(SpreadMethod::Reflect)
);
- assert_eq!(SpreadMethod::parse_str_to_parse_error("repeat"), Ok(SpreadMethod::Repeat));
- assert!(SpreadMethod::parse_str_to_parse_error("foobar").is_err());
+ assert_eq!(SpreadMethod::parse_str("repeat"), Ok(SpreadMethod::Repeat));
+ assert!(SpreadMethod::parse_str("foobar").is_err());
}
fn assert_tuples_equal(a: &(f64, f64), b: &(f64, f64)) {
@@ -814,7 +846,7 @@ mod tests {
&QualName::new(None, ns!(svg), local_name!("linearGradient")),
None,
None,
- Box::new(LinearGradient::default())
+ Box::new(LinearGradient::default()),
));
let borrow = node.borrow();
@@ -828,7 +860,7 @@ mod tests {
&QualName::new(None, ns!(svg), local_name!("radialGradient")),
None,
None,
- Box::new(RadialGradient::default())
+ Box::new(RadialGradient::default()),
));
let borrow = node.borrow();
diff --git a/rsvg_internals/src/handle.rs b/rsvg_internals/src/handle.rs
index face86c2..b7737473 100644
--- a/rsvg_internals/src/handle.rs
+++ b/rsvg_internals/src/handle.rs
@@ -35,7 +35,8 @@ pub struct LoadOptions {
/// Whether to keep original (undecoded) image data to embed in Cairo PDF surfaces.
pub keep_image_data: bool,
- /// The environment's locale, used for the `<switch>` element and the `systemLanguage` attribute.
+ /// The environment's locale, used for the `<switch>` element and the `systemLanguage`
+ /// attribute.
locale: Locale,
}
@@ -206,7 +207,11 @@ impl Handle {
cancellable: Option<&gio::Cancellable>,
) -> Result<Handle, LoadingError> {
Ok(Handle {
- document: Rc::new(Document::load_from_stream(load_options, stream, cancellable)?),
+ document: Rc::new(Document::load_from_stream(
+ load_options,
+ stream,
+ cancellable,
+ )?),
})
}
@@ -318,7 +323,10 @@ impl Handle {
let ink_rect = bbox.ink_rect.unwrap_or_default();
let logical_rect = bbox.rect.unwrap_or_default();
- Ok((cairo::Rectangle::from(ink_rect), cairo::Rectangle::from(logical_rect)))
+ Ok((
+ cairo::Rectangle::from(ink_rect),
+ cairo::Rectangle::from(logical_rect),
+ ))
}
/// Returns (ink_rect, logical_rect)
diff --git a/rsvg_internals/src/image.rs b/rsvg_internals/src/image.rs
index b16230d3..514f36fb 100644
--- a/rsvg_internals/src/image.rs
+++ b/rsvg_internals/src/image.rs
@@ -11,7 +11,7 @@ use crate::error::*;
use crate::float_eq_cairo::ApproxEqCairo;
use crate::length::*;
use crate::node::*;
-use crate::parsers::ParseValueToParseError;
+use crate::parsers::ParseValue;
use crate::property_bag::PropertyBag;
use crate::rect::Rect;
use crate::viewbox::ViewBox;
@@ -30,15 +30,15 @@ impl NodeTrait for Image {
fn set_atts(&mut self, _: Option<&RsvgNode>, pbag: &PropertyBag<'_>) -> NodeResult {
for (attr, value) in pbag.iter() {
match attr.expanded() {
- expanded_name!(svg "x") => self.x = attr.parse_to_parse_error(value)?,
- expanded_name!(svg "y") => self.y = attr.parse_to_parse_error(value)?,
+ expanded_name!(svg "x") => self.x = attr.parse(value)?,
+ expanded_name!(svg "y") => self.y = attr.parse(value)?,
expanded_name!(svg "width") => {
- self.w = attr.parse_to_parse_error_and_validate(value, Length::check_nonnegative)?
+ self.w = attr.parse_and_validate(value, Length::check_nonnegative)?
}
expanded_name!(svg "height") => {
- self.h = attr.parse_to_parse_error_and_validate(value, Length::check_nonnegative)?
+ self.h = attr.parse_and_validate(value, Length::check_nonnegative)?
}
- expanded_name!(svg "preserveAspectRatio") => self.aspect = attr.parse_to_parse_error(value)?,
+ expanded_name!(svg "preserveAspectRatio") => self.aspect = attr.parse(value)?,
// "path" is used by some older Adobe Illustrator versions
expanded_name!(xlink "href") | expanded_name!(svg "path") => {
diff --git a/rsvg_internals/src/io.rs b/rsvg_internals/src/io.rs
index 53b4992f..a48074e2 100644
--- a/rsvg_internals/src/io.rs
+++ b/rsvg_internals/src/io.rs
@@ -63,7 +63,9 @@ pub fn get_input_stream_for_loading(
let num_read = buffered.fill(2, cancellable)?;
if num_read < 2 {
// FIXME: this string was localized in the original; localize it
- return Err(LoadingError::XmlParseError(String::from("Input file is too short")));
+ return Err(LoadingError::XmlParseError(String::from(
+ "Input file is too short",
+ )));
}
let buf = buffered.peek_buffer();
@@ -87,13 +89,13 @@ pub fn acquire_stream(
if uri.starts_with("data:") {
let BinaryData { data, .. } = decode_data_uri(uri)?;
-// {
-// use std::fs::File;
-// use std::io::prelude::*;
-//
-// let mut file = File::create("data.bin").unwrap();
-// file.write_all(&data).unwrap();
-// }
+ // {
+ // use std::fs::File;
+ // use std::io::prelude::*;
+ //
+ // let mut file = File::create("data.bin").unwrap();
+ // file.write_all(&data).unwrap();
+ // }
let stream = MemoryInputStream::new_from_bytes(&GBytes::from_owned(data));
Ok(stream.upcast::<InputStream>())
diff --git a/rsvg_internals/src/iri.rs b/rsvg_internals/src/iri.rs
index 2984fee0..4ab2a3dc 100644
--- a/rsvg_internals/src/iri.rs
+++ b/rsvg_internals/src/iri.rs
@@ -4,7 +4,7 @@ use cssparser::Parser;
use crate::allowed_url::{Fragment, Href};
use crate::error::*;
-use crate::parsers::ParseToParseError;
+use crate::parsers::Parse;
/// Used where style properties take a funciri or "none"
///
@@ -34,8 +34,8 @@ impl IRI {
}
}
-impl ParseToParseError for IRI {
- fn parse_to_parse_error<'i>(parser: &mut Parser<'i, '_>) -> Result<IRI, CssParseError<'i>> {
+impl Parse for IRI {
+ fn parse<'i>(parser: &mut Parser<'i, '_>) -> Result<IRI, CssParseError<'i>> {
if parser
.try_parse(|i| i.expect_ident_matching("none"))
.is_ok()
@@ -67,18 +67,18 @@ mod tests {
#[test]
fn parses_none() {
- assert_eq!(IRI::parse_str_to_parse_error("none"), Ok(IRI::None));
+ assert_eq!(IRI::parse_str("none"), Ok(IRI::None));
}
#[test]
fn parses_url() {
assert_eq!(
- IRI::parse_str_to_parse_error("url(#bar)"),
+ IRI::parse_str("url(#bar)"),
Ok(IRI::Resource(Fragment::new(None, "bar".to_string())))
);
assert_eq!(
- IRI::parse_str_to_parse_error("url(foo#bar)"),
+ IRI::parse_str("url(foo#bar)"),
Ok(IRI::Resource(Fragment::new(
Some("foo".to_string()),
"bar".to_string()
@@ -87,19 +87,19 @@ mod tests {
// be permissive if the closing ) is missing
assert_eq!(
- IRI::parse_str_to_parse_error("url(#bar"),
+ IRI::parse_str("url(#bar"),
Ok(IRI::Resource(Fragment::new(None, "bar".to_string())))
);
assert_eq!(
- IRI::parse_str_to_parse_error("url(foo#bar"),
+ IRI::parse_str("url(foo#bar"),
Ok(IRI::Resource(Fragment::new(
Some("foo".to_string()),
"bar".to_string()
)))
);
- assert!(IRI::parse_str_to_parse_error("").is_err());
- assert!(IRI::parse_str_to_parse_error("foo").is_err());
- assert!(IRI::parse_str_to_parse_error("url(foo)bar").is_err());
+ assert!(IRI::parse_str("").is_err());
+ assert!(IRI::parse_str("foo").is_err());
+ assert!(IRI::parse_str("url(foo)bar").is_err());
}
}
diff --git a/rsvg_internals/src/length.rs b/rsvg_internals/src/length.rs
index 2f1b9102..eef0fb50 100644
--- a/rsvg_internals/src/length.rs
+++ b/rsvg_internals/src/length.rs
@@ -47,7 +47,7 @@ use std::marker::PhantomData;
use crate::drawing_ctx::ViewParams;
use crate::error::*;
-use crate::parsers::{finite_f32, ParseToParseError};
+use crate::parsers::{finite_f32, Parse};
use crate::properties::ComputedValues;
/// Units for length values.
@@ -226,10 +226,8 @@ const CM_PER_INCH: f64 = 2.54;
const MM_PER_INCH: f64 = 25.4;
const PICA_PER_INCH: f64 = 6.0;
-impl<N: Normalize> ParseToParseError for Length<N> {
- fn parse_to_parse_error<'i>(
- parser: &mut Parser<'i, '_>,
- ) -> Result<Length<N>, CssParseError<'i>> {
+impl<N: Normalize> Parse for Length<N> {
+ fn parse<'i>(parser: &mut Parser<'i, '_>) -> Result<Length<N>, CssParseError<'i>> {
let length = {
let token = parser.next()?.clone();
@@ -394,12 +392,12 @@ mod tests {
#[test]
fn parses_default() {
assert_eq!(
- Length::<Horizontal>::parse_str_to_parse_error("42"),
+ Length::<Horizontal>::parse_str("42"),
Ok(Length::<Horizontal>::new(42.0, LengthUnit::Px))
);
assert_eq!(
- Length::<Horizontal>::parse_str_to_parse_error("-42px"),
+ Length::<Horizontal>::parse_str("-42px"),
Ok(Length::<Horizontal>::new(-42.0, LengthUnit::Px))
);
}
@@ -407,7 +405,7 @@ mod tests {
#[test]
fn parses_percent() {
assert_eq!(
- Length::<Horizontal>::parse_str_to_parse_error("50.0%"),
+ Length::<Horizontal>::parse_str("50.0%"),
Ok(Length::<Horizontal>::new(0.5, LengthUnit::Percent))
);
}
@@ -415,7 +413,7 @@ mod tests {
#[test]
fn parses_font_em() {
assert_eq!(
- Length::<Vertical>::parse_str_to_parse_error("22.5em"),
+ Length::<Vertical>::parse_str("22.5em"),
Ok(Length::<Vertical>::new(22.5, LengthUnit::Em))
);
}
@@ -423,7 +421,7 @@ mod tests {
#[test]
fn parses_font_ex() {
assert_eq!(
- Length::<Vertical>::parse_str_to_parse_error("22.5ex"),
+ Length::<Vertical>::parse_str("22.5ex"),
Ok(Length::<Vertical>::new(22.5, LengthUnit::Ex))
);
}
@@ -431,51 +429,51 @@ mod tests {
#[test]
fn parses_physical_units() {
assert_eq!(
- Length::<Both>::parse_str_to_parse_error("72pt"),
+ Length::<Both>::parse_str("72pt"),
Ok(Length::<Both>::new(72.0, LengthUnit::Pt))
);
assert_eq!(
- Length::<Both>::parse_str_to_parse_error("-22.5in"),
+ Length::<Both>::parse_str("-22.5in"),
Ok(Length::<Both>::new(-22.5, LengthUnit::In))
);
assert_eq!(
- Length::<Both>::parse_str_to_parse_error("-254cm"),
+ Length::<Both>::parse_str("-254cm"),
Ok(Length::<Both>::new(-254.0, LengthUnit::Cm))
);
assert_eq!(
- Length::<Both>::parse_str_to_parse_error("254mm"),
+ Length::<Both>::parse_str("254mm"),
Ok(Length::<Both>::new(254.0, LengthUnit::Mm))
);
assert_eq!(
- Length::<Both>::parse_str_to_parse_error("60pc"),
+ Length::<Both>::parse_str("60pc"),
Ok(Length::<Both>::new(60.0, LengthUnit::Pc))
);
}
#[test]
fn empty_length_yields_error() {
- assert!(Length::<Both>::parse_str_to_parse_error("").is_err());
+ assert!(Length::<Both>::parse_str("").is_err());
}
#[test]
fn invalid_unit_yields_error() {
- assert!(Length::<Both>::parse_str_to_parse_error("8furlong").is_err());
+ assert!(Length::<Both>::parse_str("8furlong").is_err());
}
#[test]
fn check_nonnegative_works() {
// and_then with anonymous function
- assert!(Length::<Both>::parse_str_to_parse_error("0")
+ assert!(Length::<Both>::parse_str("0")
.unwrap()
.check_nonnegative()
.is_ok());
// and_then with named function
- assert!(Length::<Both>::parse_str_to_parse_error("-10")
+ assert!(Length::<Both>::parse_str("-10")
.unwrap()
.check_nonnegative()
.is_err());
diff --git a/rsvg_internals/src/lib.rs b/rsvg_internals/src/lib.rs
index 806d9382..30178697 100644
--- a/rsvg_internals/src/lib.rs
+++ b/rsvg_internals/src/lib.rs
@@ -47,7 +47,12 @@ pub use crate::dpi::{rsvg_rust_set_default_dpi_x_y, Dpi};
pub use crate::error::{DefsLookupErrorKind, HrefError, LoadingError, RenderingError};
pub use crate::handle::{
- Handle, LoadOptions, RsvgDimensionData, RsvgPositionData, RsvgSizeFunc, SizeCallback,
+ Handle,
+ LoadOptions,
+ RsvgDimensionData,
+ RsvgPositionData,
+ RsvgSizeFunc,
+ SizeCallback,
};
pub use crate::length::{Length, LengthUnit, RsvgLength};
diff --git a/rsvg_internals/src/marker.rs b/rsvg_internals/src/marker.rs
index 3423e50d..fe903137 100644
--- a/rsvg_internals/src/marker.rs
+++ b/rsvg_internals/src/marker.rs
@@ -16,7 +16,7 @@ use crate::float_eq_cairo::ApproxEqCairo;
use crate::iri::IRI;
use crate::length::*;
use crate::node::*;
-use crate::parsers::{ParseToParseError, ParseValueToParseError};
+use crate::parsers::{Parse, ParseValue};
use crate::path_builder::*;
use crate::properties::{ComputedValues, SpecifiedValue, SpecifiedValues};
use crate::property_bag::PropertyBag;
@@ -36,8 +36,8 @@ impl Default for MarkerUnits {
}
}
-impl ParseToParseError for MarkerUnits {
- fn parse_to_parse_error<'i>(parser: &mut Parser<'i, '_>) -> Result<MarkerUnits, CssParseError<'i>> {
+impl Parse for MarkerUnits {
+ fn parse<'i>(parser: &mut Parser<'i, '_>) -> Result<MarkerUnits, CssParseError<'i>> {
Ok(parse_identifiers!(
parser,
"userSpaceOnUse" => MarkerUnits::UserSpaceOnUse,
@@ -59,17 +59,15 @@ impl Default for MarkerOrient {
}
}
-impl ParseToParseError for MarkerOrient {
- fn parse_to_parse_error<'i>(
- parser: &mut Parser<'i, '_>,
- ) -> Result<MarkerOrient, CssParseError<'i>> {
+impl Parse for MarkerOrient {
+ fn parse<'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_to_parse_error(parser).map(MarkerOrient::Angle)
+ Angle::parse(parser).map(MarkerOrient::Angle)
}
}
}
@@ -92,8 +90,8 @@ impl Default for Marker {
ref_x: Default::default(),
ref_y: Default::default(),
// the following two are per the spec
- width: Length::<Horizontal>::parse_str_to_parse_error("3").unwrap(),
- height: Length::<Vertical>::parse_str_to_parse_error("3").unwrap(),
+ width: Length::<Horizontal>::parse_str("3").unwrap(),
+ height: Length::<Vertical>::parse_str("3").unwrap(),
orient: MarkerOrient::default(),
aspect: AspectRatio::default(),
vbox: None,
@@ -183,26 +181,20 @@ impl NodeTrait for Marker {
fn set_atts(&mut self, _: Option<&RsvgNode>, pbag: &PropertyBag<'_>) -> NodeResult {
for (attr, value) in pbag.iter() {
match attr.expanded() {
- expanded_name!(svg "markerUnits") => self.units = attr.parse_to_parse_error(value)?,
- 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 "markerUnits") => self.units = attr.parse(value)?,
+ expanded_name!(svg "refX") => self.ref_x = attr.parse(value)?,
+ expanded_name!(svg "refY") => self.ref_y = attr.parse(value)?,
expanded_name!(svg "markerWidth") => {
- self.width = attr.parse_to_parse_error_and_validate(
- value,
- Length::<Horizontal>::check_nonnegative,
- )?
+ self.width =
+ attr.parse_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,
- )?
- }
- expanded_name!(svg "orient") => self.orient = attr.parse_to_parse_error(value)?,
- expanded_name!(svg "preserveAspectRatio") => self.aspect = attr.parse_to_parse_error(value)?,
- expanded_name!(svg "viewBox") => {
- self.vbox = Some(attr.parse_to_parse_error(value)?)
+ self.height =
+ attr.parse_and_validate(value, Length::<Vertical>::check_nonnegative)?
}
+ expanded_name!(svg "orient") => self.orient = attr.parse(value)?,
+ expanded_name!(svg "preserveAspectRatio") => self.aspect = attr.parse(value)?,
+ expanded_name!(svg "viewBox") => self.vbox = Some(attr.parse(value)?),
_ => (),
}
}
@@ -522,7 +514,8 @@ impl Segments {
for segment in self[..=start_index].iter().rev() {
match *segment {
Segment::Degenerate { .. } => {
- return (false, 0.0, 0.0); // reached the beginning of the subpath as we ran into a
standalone point
+ return (false, 0.0, 0.0); // reached the beginning of the subpath as we ran into
+ // a standalone point
}
Segment::LineOrCurve { .. } => match segment.get_directionalities() {
@@ -545,7 +538,8 @@ impl Segments {
for segment in &self[start_index..] {
match *segment {
Segment::Degenerate { .. } => {
- return (false, 0.0, 0.0); // reached the end of a subpath as we ran into a standalone
point
+ return (false, 0.0, 0.0); // reached the end of a subpath as we ran into a
+ // standalone point
}
Segment::LineOrCurve { .. } => match segment.get_directionalities() {
@@ -812,51 +806,51 @@ mod parser_tests {
#[test]
fn parsing_invalid_marker_units_yields_error() {
- assert!(MarkerUnits::parse_str_to_parse_error("").is_err());
- assert!(MarkerUnits::parse_str_to_parse_error("foo").is_err());
+ assert!(MarkerUnits::parse_str("").is_err());
+ assert!(MarkerUnits::parse_str("foo").is_err());
}
#[test]
fn parses_marker_units() {
assert_eq!(
- MarkerUnits::parse_str_to_parse_error("userSpaceOnUse"),
+ MarkerUnits::parse_str("userSpaceOnUse"),
Ok(MarkerUnits::UserSpaceOnUse)
);
assert_eq!(
- MarkerUnits::parse_str_to_parse_error("strokeWidth"),
+ MarkerUnits::parse_str("strokeWidth"),
Ok(MarkerUnits::StrokeWidth)
);
}
#[test]
fn parsing_invalid_marker_orient_yields_error() {
- 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());
+ assert!(MarkerOrient::parse_str("").is_err());
+ assert!(MarkerOrient::parse_str("blah").is_err());
+ assert!(MarkerOrient::parse_str("45blah").is_err());
}
#[test]
fn parses_marker_orient() {
- assert_eq!(MarkerOrient::parse_str_to_parse_error("auto"), Ok(MarkerOrient::Auto));
+ assert_eq!(MarkerOrient::parse_str("auto"), Ok(MarkerOrient::Auto));
assert_eq!(
- MarkerOrient::parse_str_to_parse_error("0"),
+ MarkerOrient::parse_str("0"),
Ok(MarkerOrient::Angle(Angle::new(0.0)))
);
assert_eq!(
- MarkerOrient::parse_str_to_parse_error("180"),
+ MarkerOrient::parse_str("180"),
Ok(MarkerOrient::Angle(Angle::from_degrees(180.0)))
);
assert_eq!(
- MarkerOrient::parse_str_to_parse_error("180deg"),
+ MarkerOrient::parse_str("180deg"),
Ok(MarkerOrient::Angle(Angle::from_degrees(180.0)))
);
assert_eq!(
- MarkerOrient::parse_str_to_parse_error("-400grad"),
+ MarkerOrient::parse_str("-400grad"),
Ok(MarkerOrient::Angle(Angle::from_degrees(-360.0)))
);
assert_eq!(
- MarkerOrient::parse_str_to_parse_error("1rad"),
+ MarkerOrient::parse_str("1rad"),
Ok(MarkerOrient::Angle(Angle::new(1.0)))
);
}
diff --git a/rsvg_internals/src/mask.rs b/rsvg_internals/src/mask.rs
index 75a82167..746b83ff 100644
--- a/rsvg_internals/src/mask.rs
+++ b/rsvg_internals/src/mask.rs
@@ -9,7 +9,7 @@ use crate::drawing_ctx::{CompositingAffines, DrawingCtx};
use crate::error::RenderingError;
use crate::length::*;
use crate::node::{CascadedValues, NodeDraw, NodeResult, NodeTrait, RsvgNode};
-use crate::parsers::{ParseToParseError, ParseValueToParseError};
+use crate::parsers::{Parse, ParseValue};
use crate::property_bag::PropertyBag;
use crate::property_defs::Opacity;
use crate::rect::Rect;
@@ -32,10 +32,10 @@ impl Default for Mask {
fn default() -> Mask {
Mask {
// these values are per the spec
- x: Length::<Horizontal>::parse_str_to_parse_error("-10%").unwrap(),
- y: Length::<Vertical>::parse_str_to_parse_error("-10%").unwrap(),
- width: Length::<Horizontal>::parse_str_to_parse_error("120%").unwrap(),
- height: Length::<Vertical>::parse_str_to_parse_error("120%").unwrap(),
+ x: Length::<Horizontal>::parse_str("-10%").unwrap(),
+ y: Length::<Vertical>::parse_str("-10%").unwrap(),
+ width: Length::<Horizontal>::parse_str("120%").unwrap(),
+ height: Length::<Vertical>::parse_str("120%").unwrap(),
units: MaskUnits::default(),
content_units: MaskContentUnits::default(),
@@ -136,18 +136,18 @@ impl NodeTrait for Mask {
fn set_atts(&mut self, _: Option<&RsvgNode>, pbag: &PropertyBag<'_>) -> NodeResult {
for (attr, value) in pbag.iter() {
match attr.expanded() {
- expanded_name!(svg "x") => self.x = attr.parse_to_parse_error(value)?,
- expanded_name!(svg "y") => self.y = attr.parse_to_parse_error(value)?,
+ expanded_name!(svg "x") => self.x = attr.parse(value)?,
+ expanded_name!(svg "y") => self.y = attr.parse(value)?,
expanded_name!(svg "width") => {
self.width =
- attr.parse_to_parse_error_and_validate(value,
Length::<Horizontal>::check_nonnegative)?
+ attr.parse_and_validate(value, Length::<Horizontal>::check_nonnegative)?
}
expanded_name!(svg "height") => {
self.height =
- attr.parse_to_parse_error_and_validate(value, Length::<Vertical>::check_nonnegative)?
+ attr.parse_and_validate(value, Length::<Vertical>::check_nonnegative)?
}
- expanded_name!(svg "maskUnits") => self.units = attr.parse_to_parse_error(value)?,
- expanded_name!(svg "maskContentUnits") => self.content_units =
attr.parse_to_parse_error(value)?,
+ expanded_name!(svg "maskUnits") => self.units = attr.parse(value)?,
+ expanded_name!(svg "maskContentUnits") => self.content_units = attr.parse(value)?,
_ => (),
}
}
diff --git a/rsvg_internals/src/node.rs b/rsvg_internals/src/node.rs
index feb5d5a5..b3dd0130 100644
--- a/rsvg_internals/src/node.rs
+++ b/rsvg_internals/src/node.rs
@@ -25,7 +25,7 @@ use crate::css::Declaration;
use crate::drawing_ctx::DrawingCtx;
use crate::error::*;
use crate::filters::FilterEffect;
-use crate::parsers::ParseToParseError;
+use crate::parsers::Parse;
use crate::properties::{ComputedValues, SpecifiedValue, SpecifiedValues};
use crate::property_bag::PropertyBag;
use crate::property_defs::Overflow;
@@ -155,7 +155,7 @@ impl NodeData {
for (attr, value) in pbag.iter() {
match attr.expanded() {
expanded_name!(svg "transform") => {
- return Matrix::parse_str_to_parse_error(value).attribute(attr).and_then(|affine| {
+ return Matrix::parse_str(value).attribute(attr).and_then(|affine| {
self.transform = affine;
Ok(())
});
diff --git a/rsvg_internals/src/number_list.rs b/rsvg_internals/src/number_list.rs
index efb6e661..e0768ea5 100644
--- a/rsvg_internals/src/number_list.rs
+++ b/rsvg_internals/src/number_list.rs
@@ -3,7 +3,7 @@
use cssparser::{Parser, ParserInput};
use crate::error::*;
-use crate::parsers::{optional_comma, ParseToParseError};
+use crate::parsers::{optional_comma, Parse};
#[derive(Eq, PartialEq)]
pub enum NumberListLength {
@@ -15,7 +15,7 @@ pub enum NumberListLength {
pub struct NumberList(pub Vec<f64>);
impl NumberList {
- pub fn parse_to_parse_error<'i>(
+ pub fn parse<'i>(
parser: &mut Parser<'i, '_>,
length: NumberListLength,
) -> Result<Self, CssParseError<'i>> {
@@ -34,7 +34,7 @@ impl NumberList {
optional_comma(parser);
}
- v.push(f64::parse_to_parse_error(parser)?);
+ v.push(f64::parse(parser)?);
if let NumberListLength::Exact(l) = length {
if i + 1 == l {
@@ -59,11 +59,14 @@ impl NumberList {
Ok(NumberList(v))
}
- pub fn parse_str_to_parse_error<'i>(s: &'i str, length: NumberListLength) -> Result<NumberList,
CssParseError<'i>> {
+ pub fn parse_str<'i>(
+ s: &'i str,
+ length: NumberListLength,
+ ) -> Result<NumberList, CssParseError<'i>> {
let mut input = ParserInput::new(s);
let mut parser = Parser::new(&mut input);
- Self::parse_to_parse_error(&mut parser, length).and_then(|r| {
+ Self::parse(&mut parser, length).and_then(|r| {
// FIXME: parser.expect_exhausted()?;
Ok(r)
})
@@ -77,22 +80,22 @@ mod tests {
#[test]
fn parses_number_list() {
assert_eq!(
- NumberList::parse_str_to_parse_error("5", NumberListLength::Exact(1)),
+ NumberList::parse_str("5", NumberListLength::Exact(1)),
Ok(NumberList(vec![5.0]))
);
assert_eq!(
- NumberList::parse_str_to_parse_error("1 2 3 4", NumberListLength::Exact(4)),
+ NumberList::parse_str("1 2 3 4", NumberListLength::Exact(4)),
Ok(NumberList(vec![1.0, 2.0, 3.0, 4.0]))
);
assert_eq!(
- NumberList::parse_str_to_parse_error("", NumberListLength::Unbounded),
+ NumberList::parse_str("", NumberListLength::Unbounded),
Ok(NumberList(vec![]))
);
assert_eq!(
- NumberList::parse_str_to_parse_error("1, 2, 3.0, 4, 5", NumberListLength::Unbounded),
+ NumberList::parse_str("1, 2, 3.0, 4, 5", NumberListLength::Unbounded),
Ok(NumberList(vec![1.0, 2.0, 3.0, 4.0, 5.0]))
);
}
@@ -100,25 +103,25 @@ mod tests {
#[test]
fn errors_on_invalid_number_list() {
// empty
- assert!(NumberList::parse_str_to_parse_error("", NumberListLength::Exact(1)).is_err());
+ assert!(NumberList::parse_str("", NumberListLength::Exact(1)).is_err());
// garbage
- assert!(NumberList::parse_str_to_parse_error("foo", NumberListLength::Exact(1)).is_err());
- assert!(NumberList::parse_str_to_parse_error("1foo", NumberListLength::Exact(2)).is_err());
- assert!(NumberList::parse_str_to_parse_error("1 foo", NumberListLength::Exact(2)).is_err());
- assert!(NumberList::parse_str_to_parse_error("1 foo 2", NumberListLength::Exact(2)).is_err());
- assert!(NumberList::parse_str_to_parse_error("1,foo", NumberListLength::Exact(2)).is_err());
+ assert!(NumberList::parse_str("foo", NumberListLength::Exact(1)).is_err());
+ assert!(NumberList::parse_str("1foo", NumberListLength::Exact(2)).is_err());
+ assert!(NumberList::parse_str("1 foo", NumberListLength::Exact(2)).is_err());
+ assert!(NumberList::parse_str("1 foo 2", NumberListLength::Exact(2)).is_err());
+ assert!(NumberList::parse_str("1,foo", NumberListLength::Exact(2)).is_err());
// too many
- assert!(NumberList::parse_str_to_parse_error("1 2", NumberListLength::Exact(1)).is_err());
+ assert!(NumberList::parse_str("1 2", NumberListLength::Exact(1)).is_err());
// extra token
- assert!(NumberList::parse_str_to_parse_error("1,", NumberListLength::Exact(1)).is_err());
- assert!(NumberList::parse_str_to_parse_error("1,", NumberListLength::Exact(1)).is_err());
- assert!(NumberList::parse_str_to_parse_error("1,", NumberListLength::Unbounded).is_err());
+ assert!(NumberList::parse_str("1,", NumberListLength::Exact(1)).is_err());
+ assert!(NumberList::parse_str("1,", NumberListLength::Exact(1)).is_err());
+ assert!(NumberList::parse_str("1,", NumberListLength::Unbounded).is_err());
// too few
- assert!(NumberList::parse_str_to_parse_error("1", NumberListLength::Exact(2)).is_err());
- assert!(NumberList::parse_str_to_parse_error("1 2", NumberListLength::Exact(3)).is_err());
+ assert!(NumberList::parse_str("1", NumberListLength::Exact(2)).is_err());
+ assert!(NumberList::parse_str("1 2", NumberListLength::Exact(3)).is_err());
}
}
diff --git a/rsvg_internals/src/paint_server.rs b/rsvg_internals/src/paint_server.rs
index 20739b83..254b1a77 100644
--- a/rsvg_internals/src/paint_server.rs
+++ b/rsvg_internals/src/paint_server.rs
@@ -7,7 +7,7 @@ use crate::bbox::BoundingBox;
use crate::drawing_ctx::DrawingCtx;
use crate::error::*;
use crate::node::{CascadedValues, RsvgNode};
-use crate::parsers::ParseToParseError;
+use crate::parsers::Parse;
use crate::properties::ComputedValues;
use crate::unit_interval::UnitInterval;
@@ -21,10 +21,8 @@ pub enum PaintServer {
SolidColor(cssparser::Color),
}
-impl ParseToParseError for PaintServer {
- fn parse_to_parse_error<'i>(
- parser: &mut Parser<'i, '_>,
- ) -> Result<PaintServer, CssParseError<'i>> {
+impl Parse for PaintServer {
+ fn parse<'i>(parser: &mut Parser<'i, '_>) -> Result<PaintServer, CssParseError<'i>> {
if parser
.try_parse(|i| i.expect_ident_matching("none"))
.is_ok()
@@ -128,27 +126,27 @@ mod tests {
#[test]
fn catches_invalid_syntax() {
- assert!(PaintServer::parse_str_to_parse_error("").is_err());
- assert!(PaintServer::parse_str_to_parse_error("42").is_err());
- assert!(PaintServer::parse_str_to_parse_error("invalid").is_err());
+ assert!(PaintServer::parse_str("").is_err());
+ assert!(PaintServer::parse_str("42").is_err());
+ assert!(PaintServer::parse_str("invalid").is_err());
}
#[test]
fn parses_none() {
- assert_eq!(PaintServer::parse_str_to_parse_error("none"), Ok(PaintServer::None));
+ assert_eq!(PaintServer::parse_str("none"), Ok(PaintServer::None));
}
#[test]
fn parses_solid_color() {
assert_eq!(
- PaintServer::parse_str_to_parse_error("rgb(255, 128, 64, 0.5)"),
+ PaintServer::parse_str("rgb(255, 128, 64, 0.5)"),
Ok(PaintServer::SolidColor(cssparser::Color::RGBA(
cssparser::RGBA::new(255, 128, 64, 128)
)))
);
assert_eq!(
- PaintServer::parse_str_to_parse_error("currentColor"),
+ PaintServer::parse_str("currentColor"),
Ok(PaintServer::SolidColor(cssparser::Color::CurrentColor))
);
}
@@ -156,7 +154,7 @@ mod tests {
#[test]
fn parses_iri() {
assert_eq!(
- PaintServer::parse_str_to_parse_error("url(#link)"),
+ PaintServer::parse_str("url(#link)"),
Ok(PaintServer::Iri {
iri: Fragment::new(None, "link".to_string()),
alternate: None,
@@ -164,7 +162,7 @@ mod tests {
);
assert_eq!(
- PaintServer::parse_str_to_parse_error("url(foo#link) none"),
+ PaintServer::parse_str("url(foo#link) none"),
Ok(PaintServer::Iri {
iri: Fragment::new(Some("foo".to_string()), "link".to_string()),
alternate: None,
@@ -172,7 +170,7 @@ mod tests {
);
assert_eq!(
- PaintServer::parse_str_to_parse_error("url(#link) #ff8040"),
+ PaintServer::parse_str("url(#link) #ff8040"),
Ok(PaintServer::Iri {
iri: Fragment::new(None, "link".to_string()),
alternate: Some(cssparser::Color::RGBA(cssparser::RGBA::new(
@@ -182,7 +180,7 @@ mod tests {
);
assert_eq!(
- PaintServer::parse_str_to_parse_error("url(#link) rgb(255, 128, 64, 0.5)"),
+ PaintServer::parse_str("url(#link) rgb(255, 128, 64, 0.5)"),
Ok(PaintServer::Iri {
iri: Fragment::new(None, "link".to_string()),
alternate: Some(cssparser::Color::RGBA(cssparser::RGBA::new(
@@ -192,13 +190,13 @@ mod tests {
);
assert_eq!(
- PaintServer::parse_str_to_parse_error("url(#link) currentColor"),
+ PaintServer::parse_str("url(#link) currentColor"),
Ok(PaintServer::Iri {
iri: Fragment::new(None, "link".to_string()),
alternate: Some(cssparser::Color::CurrentColor),
},)
);
- assert!(PaintServer::parse_str_to_parse_error("url(#link) invalid").is_err());
+ assert!(PaintServer::parse_str("url(#link) invalid").is_err());
}
}
diff --git a/rsvg_internals/src/parsers.rs b/rsvg_internals/src/parsers.rs
index b8891145..be6d5863 100644
--- a/rsvg_internals/src/parsers.rs
+++ b/rsvg_internals/src/parsers.rs
@@ -8,21 +8,21 @@ use std::str;
use crate::error::*;
/// Trait to parse values using `cssparser::Parser`.
-pub trait ParseToParseError: Sized {
+pub trait Parse: Sized {
/// Parses a value out of the `parser`.
///
/// All value types should implement this for composability.
- fn parse_to_parse_error<'i>(parser: &mut Parser<'i, '_>) -> Result<Self, CssParseError<'i>>;
+ fn parse<'i>(parser: &mut Parser<'i, '_>) -> Result<Self, CssParseError<'i>>;
/// Convenience function to parse a value out of a `&str`.
///
/// This is useful mostly for tests which want to avoid creating a
/// `cssparser::Parser` by hand.
- fn parse_str_to_parse_error<'i>(s: &'i str) -> Result<Self, CssParseError<'i>> {
+ fn parse_str<'i>(s: &'i str) -> Result<Self, CssParseError<'i>> {
let mut input = ParserInput::new(s);
let mut parser = Parser::new(&mut input);
- Self::parse_to_parse_error(&mut parser).and_then(|r| {
+ Self::parse(&mut parser).and_then(|r| {
// FIXME: parser.expect_exhausted()?;
Ok(r)
})
@@ -42,27 +42,27 @@ pub fn finite_f32(n: f32) -> Result<f32, ValueErrorKind> {
}
}
-pub trait ParseValueToParseError<T: ParseToParseError> {
+pub trait ParseValue<T: Parse> {
/// Parses a `value` string into a type `T`.
- fn parse_to_parse_error(&self, value: &str) -> Result<T, NodeError>;
+ fn parse(&self, value: &str) -> Result<T, NodeError>;
/// Parses a `value` string into a type `T` with an optional validation function.
- fn parse_to_parse_error_and_validate<F: FnOnce(T) -> Result<T, ValueErrorKind>>(
+ fn parse_and_validate<F: FnOnce(T) -> Result<T, ValueErrorKind>>(
&self,
value: &str,
validate: F,
) -> Result<T, NodeError>;
}
-impl<T: ParseToParseError> ParseValueToParseError<T> for QualName {
- fn parse_to_parse_error(&self, value: &str) -> Result<T, NodeError> {
+impl<T: Parse> ParseValue<T> for QualName {
+ fn parse(&self, value: &str) -> Result<T, NodeError> {
let mut input = ParserInput::new(value);
let mut parser = Parser::new(&mut input);
- T::parse_to_parse_error(&mut parser).attribute(self.clone())
+ T::parse(&mut parser).attribute(self.clone())
}
- fn parse_to_parse_error_and_validate<F: FnOnce(T) -> Result<T, ValueErrorKind>>(
+ fn parse_and_validate<F: FnOnce(T) -> Result<T, ValueErrorKind>>(
&self,
value: &str,
validate: F,
@@ -70,25 +70,24 @@ impl<T: ParseToParseError> ParseValueToParseError<T> for QualName {
let mut input = ParserInput::new(value);
let mut parser = Parser::new(&mut input);
- let v = T::parse_to_parse_error(&mut parser).attribute(self.clone())?;
+ let v = T::parse(&mut parser).attribute(self.clone())?;
- validate(v).map_err(|e| parser.new_custom_error(e)).attribute(self.clone())
+ validate(v)
+ .map_err(|e| parser.new_custom_error(e))
+ .attribute(self.clone())
}
}
-impl ParseToParseError for f64 {
- fn parse_to_parse_error<'i>(parser: &mut Parser<'i, '_>) -> Result<Self, CssParseError<'i>> {
+impl Parse for f64 {
+ fn parse<'i>(parser: &mut Parser<'i, '_>) -> Result<Self, CssParseError<'i>> {
let loc = parser.current_source_location();
- parser
- .expect_number()
- .map_err(|e| e.into())
- .and_then(|n| {
- if n.is_finite() {
- Ok(f64::from(n))
- } else {
- Err(loc.new_custom_error(ValueErrorKind::value_error("expected finite number")))
- }
- })
+ parser.expect_number().map_err(|e| e.into()).and_then(|n| {
+ if n.is_finite() {
+ Ok(f64::from(n))
+ } else {
+ Err(loc.new_custom_error(ValueErrorKind::value_error("expected finite number")))
+ }
+ })
}
}
@@ -96,15 +95,15 @@ impl ParseToParseError for f64 {
///
/// https://www.w3.org/TR/SVG/types.html#DataTypeNumberOptionalNumber
#[derive(Debug, Copy, Clone, PartialEq)]
-pub struct NumberOptionalNumber<T: ParseToParseError>(pub T, pub T);
+pub struct NumberOptionalNumber<T: Parse>(pub T, pub T);
-impl<T: ParseToParseError + Copy> ParseToParseError for NumberOptionalNumber<T> {
- fn parse_to_parse_error<'i>(parser: &mut Parser<'i, '_>) -> Result<Self, CssParseError<'i>> {
- let x = ParseToParseError::parse_to_parse_error(parser)?;
+impl<T: Parse + Copy> Parse for NumberOptionalNumber<T> {
+ fn parse<'i>(parser: &mut Parser<'i, '_>) -> Result<Self, CssParseError<'i>> {
+ let x = Parse::parse(parser)?;
if !parser.is_exhausted() {
optional_comma(parser);
- let y = ParseToParseError::parse_to_parse_error(parser)?;
+ let y = Parse::parse(parser)?;
parser.expect_exhausted()?;
Ok(NumberOptionalNumber(x, y))
} else {
@@ -113,11 +112,11 @@ impl<T: ParseToParseError + Copy> ParseToParseError for NumberOptionalNumber<T>
}
}
-impl ParseToParseError for i32 {
+impl Parse for i32 {
/// CSS integer
///
/// https://www.w3.org/TR/SVG11/types.html#DataTypeInteger
- fn parse_to_parse_error<'i>(parser: &mut Parser<'i, '_>) -> Result<Self, CssParseError<'i>> {
+ fn parse<'i>(parser: &mut Parser<'i, '_>) -> Result<Self, CssParseError<'i>> {
Ok(parser.expect_integer()?)
}
}
@@ -156,96 +155,96 @@ mod tests {
#[test]
fn parses_number_optional_number() {
assert_eq!(
- NumberOptionalNumber::parse_str_to_parse_error("1, 2"),
+ NumberOptionalNumber::parse_str("1, 2"),
Ok(NumberOptionalNumber(1.0, 2.0))
);
assert_eq!(
- NumberOptionalNumber::parse_str_to_parse_error("1 2"),
+ NumberOptionalNumber::parse_str("1 2"),
Ok(NumberOptionalNumber(1.0, 2.0))
);
assert_eq!(
- NumberOptionalNumber::parse_str_to_parse_error("1"),
+ NumberOptionalNumber::parse_str("1"),
Ok(NumberOptionalNumber(1.0, 1.0))
);
assert_eq!(
- NumberOptionalNumber::parse_str_to_parse_error("-1, -2"),
+ NumberOptionalNumber::parse_str("-1, -2"),
Ok(NumberOptionalNumber(-1.0, -2.0))
);
assert_eq!(
- NumberOptionalNumber::parse_str_to_parse_error("-1 -2"),
+ NumberOptionalNumber::parse_str("-1 -2"),
Ok(NumberOptionalNumber(-1.0, -2.0))
);
assert_eq!(
- NumberOptionalNumber::parse_str_to_parse_error("-1"),
+ NumberOptionalNumber::parse_str("-1"),
Ok(NumberOptionalNumber(-1.0, -1.0))
);
}
#[test]
fn invalid_number_optional_number() {
- assert!(NumberOptionalNumber::<f64>::parse_str_to_parse_error("").is_err());
- assert!(NumberOptionalNumber::<f64>::parse_str_to_parse_error("1x").is_err());
- assert!(NumberOptionalNumber::<f64>::parse_str_to_parse_error("x1").is_err());
- assert!(NumberOptionalNumber::<f64>::parse_str_to_parse_error("1 x").is_err());
- assert!(NumberOptionalNumber::<f64>::parse_str_to_parse_error("1 , x").is_err());
- assert!(NumberOptionalNumber::<f64>::parse_str_to_parse_error("1 , 2x").is_err());
- assert!(NumberOptionalNumber::<f64>::parse_str_to_parse_error("1 2 x").is_err());
+ assert!(NumberOptionalNumber::<f64>::parse_str("").is_err());
+ assert!(NumberOptionalNumber::<f64>::parse_str("1x").is_err());
+ assert!(NumberOptionalNumber::<f64>::parse_str("x1").is_err());
+ assert!(NumberOptionalNumber::<f64>::parse_str("1 x").is_err());
+ assert!(NumberOptionalNumber::<f64>::parse_str("1 , x").is_err());
+ assert!(NumberOptionalNumber::<f64>::parse_str("1 , 2x").is_err());
+ assert!(NumberOptionalNumber::<f64>::parse_str("1 2 x").is_err());
}
#[test]
fn parses_integer() {
- assert_eq!(i32::parse_str_to_parse_error("1"), Ok(1));
- assert_eq!(i32::parse_str_to_parse_error("-1"), Ok(-1));
+ assert_eq!(i32::parse_str("1"), Ok(1));
+ assert_eq!(i32::parse_str("-1"), Ok(-1));
}
#[test]
fn invalid_integer() {
- assert!(i32::parse_str_to_parse_error("").is_err());
- assert!(i32::parse_str_to_parse_error("1x").is_err());
- assert!(i32::parse_str_to_parse_error("1.5").is_err());
+ assert!(i32::parse_str("").is_err());
+ assert!(i32::parse_str("1x").is_err());
+ assert!(i32::parse_str("1.5").is_err());
}
#[test]
fn parses_integer_optional_integer() {
assert_eq!(
- NumberOptionalNumber::parse_str_to_parse_error("1, 2"),
+ NumberOptionalNumber::parse_str("1, 2"),
Ok(NumberOptionalNumber(1, 2))
);
assert_eq!(
- NumberOptionalNumber::parse_str_to_parse_error("1 2"),
+ NumberOptionalNumber::parse_str("1 2"),
Ok(NumberOptionalNumber(1, 2))
);
assert_eq!(
- NumberOptionalNumber::parse_str_to_parse_error("1"),
+ NumberOptionalNumber::parse_str("1"),
Ok(NumberOptionalNumber(1, 1))
);
assert_eq!(
- NumberOptionalNumber::parse_str_to_parse_error("-1, -2"),
+ NumberOptionalNumber::parse_str("-1, -2"),
Ok(NumberOptionalNumber(-1, -2))
);
assert_eq!(
- NumberOptionalNumber::parse_str_to_parse_error("-1 -2"),
+ NumberOptionalNumber::parse_str("-1 -2"),
Ok(NumberOptionalNumber(-1, -2))
);
assert_eq!(
- NumberOptionalNumber::parse_str_to_parse_error("-1"),
+ NumberOptionalNumber::parse_str("-1"),
Ok(NumberOptionalNumber(-1, -1))
);
}
#[test]
fn invalid_integer_optional_integer() {
- assert!(NumberOptionalNumber::<i32>::parse_str_to_parse_error("").is_err());
- assert!(NumberOptionalNumber::<i32>::parse_str_to_parse_error("1x").is_err());
- assert!(NumberOptionalNumber::<i32>::parse_str_to_parse_error("x1").is_err());
- assert!(NumberOptionalNumber::<i32>::parse_str_to_parse_error("1 x").is_err());
- assert!(NumberOptionalNumber::<i32>::parse_str_to_parse_error("1 , x").is_err());
- assert!(NumberOptionalNumber::<i32>::parse_str_to_parse_error("1 , 2x").is_err());
- assert!(NumberOptionalNumber::<i32>::parse_str_to_parse_error("1 2 x").is_err());
- assert!(NumberOptionalNumber::<i32>::parse_str_to_parse_error("1.5").is_err());
- assert!(NumberOptionalNumber::<i32>::parse_str_to_parse_error("1 2.5").is_err());
- assert!(NumberOptionalNumber::<i32>::parse_str_to_parse_error("1, 2.5").is_err());
+ assert!(NumberOptionalNumber::<i32>::parse_str("").is_err());
+ assert!(NumberOptionalNumber::<i32>::parse_str("1x").is_err());
+ assert!(NumberOptionalNumber::<i32>::parse_str("x1").is_err());
+ assert!(NumberOptionalNumber::<i32>::parse_str("1 x").is_err());
+ assert!(NumberOptionalNumber::<i32>::parse_str("1 , x").is_err());
+ assert!(NumberOptionalNumber::<i32>::parse_str("1 , 2x").is_err());
+ assert!(NumberOptionalNumber::<i32>::parse_str("1 2 x").is_err());
+ assert!(NumberOptionalNumber::<i32>::parse_str("1.5").is_err());
+ assert!(NumberOptionalNumber::<i32>::parse_str("1 2.5").is_err());
+ assert!(NumberOptionalNumber::<i32>::parse_str("1, 2.5").is_err());
}
}
diff --git a/rsvg_internals/src/pattern.rs b/rsvg_internals/src/pattern.rs
index 488023ce..d189760b 100644
--- a/rsvg_internals/src/pattern.rs
+++ b/rsvg_internals/src/pattern.rs
@@ -15,7 +15,7 @@ use crate::float_eq_cairo::ApproxEqCairo;
use crate::length::*;
use crate::node::*;
use crate::paint_server::{AsPaintSource, PaintSource};
-use crate::parsers::ParseValueToParseError;
+use crate::parsers::ParseValue;
use crate::properties::ComputedValues;
use crate::property_bag::PropertyBag;
use crate::rect::Rect;
@@ -120,30 +120,30 @@ impl NodeTrait for Pattern {
fn set_atts(&mut self, _: Option<&RsvgNode>, pbag: &PropertyBag<'_>) -> NodeResult {
for (attr, value) in pbag.iter() {
match attr.expanded() {
- expanded_name!(svg "patternUnits") => self.common.units =
Some(attr.parse_to_parse_error(value)?),
+ expanded_name!(svg "patternUnits") => self.common.units = Some(attr.parse(value)?),
expanded_name!(svg "patternContentUnits") => {
- self.common.content_units = Some(attr.parse_to_parse_error(value)?)
+ self.common.content_units = Some(attr.parse(value)?)
}
- expanded_name!(svg "viewBox") => self.common.vbox =
Some(Some(attr.parse_to_parse_error(value)?)),
+ expanded_name!(svg "viewBox") => self.common.vbox = Some(Some(attr.parse(value)?)),
expanded_name!(svg "preserveAspectRatio") => {
- self.common.preserve_aspect_ratio = Some(attr.parse_to_parse_error(value)?)
+ self.common.preserve_aspect_ratio = Some(attr.parse(value)?)
}
expanded_name!(svg "patternTransform") => {
- self.common.affine = Some(attr.parse_to_parse_error(value)?)
+ self.common.affine = Some(attr.parse(value)?)
}
expanded_name!(xlink "href") => {
self.fallback = Some(Fragment::parse(value).attribute(attr)?);
}
- expanded_name!(svg "x") => self.common.x = Some(attr.parse_to_parse_error(value)?),
- expanded_name!(svg "y") => self.common.y = Some(attr.parse_to_parse_error(value)?),
+ expanded_name!(svg "x") => self.common.x = Some(attr.parse(value)?),
+ expanded_name!(svg "y") => self.common.y = Some(attr.parse(value)?),
expanded_name!(svg "width") => {
self.common.width = Some(
- attr.parse_to_parse_error_and_validate(value,
Length::<Horizontal>::check_nonnegative)?,
+ attr.parse_and_validate(value, Length::<Horizontal>::check_nonnegative)?,
)
}
expanded_name!(svg "height") => {
self.common.height =
- Some(attr.parse_to_parse_error_and_validate(value,
Length::<Vertical>::check_nonnegative)?)
+ Some(attr.parse_and_validate(value, Length::<Vertical>::check_nonnegative)?)
}
_ => (),
}
@@ -314,10 +314,8 @@ impl AsPaintSource for ResolvedPattern {
// Create the pattern contents coordinate system
let _params = if let Some(vbox) = vbox {
// If there is a vbox, use that
- let r = preserve_aspect_ratio.compute(
- &vbox,
- &Rect::from_size(scaled_width, scaled_height),
- );
+ let r =
+ preserve_aspect_ratio.compute(&vbox, &Rect::from_size(scaled_width, scaled_height));
let sw = r.width() / vbox.0.width();
let sh = r.height() / vbox.0.height();
diff --git a/rsvg_internals/src/properties.rs b/rsvg_internals/src/properties.rs
index 63b293f1..a14a794c 100644
--- a/rsvg_internals/src/properties.rs
+++ b/rsvg_internals/src/properties.rs
@@ -1,14 +1,20 @@
//! CSS properties, specified values, computed values.
use cssparser::{
- self, BasicParseErrorKind, DeclarationListParser, ParseErrorKind, Parser, ParserInput, ToCss,
+ self,
+ BasicParseErrorKind,
+ DeclarationListParser,
+ ParseErrorKind,
+ Parser,
+ ParserInput,
+ ToCss,
};
use markup5ever::{expanded_name, local_name, namespace_url, ns, QualName};
use std::collections::HashSet;
use crate::css::{DeclParser, Declaration};
use crate::error::*;
-use crate::parsers::{ParseToParseError, ParseValueToParseError};
+use crate::parsers::{Parse, ParseValue};
use crate::property_bag::PropertyBag;
use crate::property_defs::*;
use crate::property_macros::Property;
@@ -231,147 +237,147 @@ pub fn parse_property<'i>(prop_name: &QualName, input: &mut Parser<'i, '_>, acce
// please keep these sorted
match prop_name.expanded() {
expanded_name!(svg "baseline-shift") =>
- Ok(ParsedProperty::BaselineShift(parse_input_to_parse_error(input)?)),
+ Ok(ParsedProperty::BaselineShift(parse_input(input)?)),
expanded_name!(svg "clip-path") =>
- Ok(ParsedProperty::ClipPath(parse_input_to_parse_error(input)?)),
+ Ok(ParsedProperty::ClipPath(parse_input(input)?)),
expanded_name!(svg "clip-rule") =>
- Ok(ParsedProperty::ClipRule(parse_input_to_parse_error(input)?)),
+ Ok(ParsedProperty::ClipRule(parse_input(input)?)),
expanded_name!(svg "color") =>
- Ok(ParsedProperty::Color(parse_input_to_parse_error(input)?)),
+ Ok(ParsedProperty::Color(parse_input(input)?)),
expanded_name!(svg "color-interpolation-filters") =>
- Ok(ParsedProperty::ColorInterpolationFilters(parse_input_to_parse_error(input)?)),
+ Ok(ParsedProperty::ColorInterpolationFilters(parse_input(input)?)),
expanded_name!(svg "direction") =>
- Ok(ParsedProperty::Direction(parse_input_to_parse_error(input)?)),
+ Ok(ParsedProperty::Direction(parse_input(input)?)),
expanded_name!(svg "display") =>
- Ok(ParsedProperty::Display(parse_input_to_parse_error(input)?)),
+ Ok(ParsedProperty::Display(parse_input(input)?)),
expanded_name!(svg "enable-background") =>
- Ok(ParsedProperty::EnableBackground(parse_input_to_parse_error(input)?)),
+ Ok(ParsedProperty::EnableBackground(parse_input(input)?)),
expanded_name!(svg "fill") =>
- Ok(ParsedProperty::Fill(parse_input_to_parse_error(input)?)),
+ Ok(ParsedProperty::Fill(parse_input(input)?)),
expanded_name!(svg "fill-opacity") =>
- Ok(ParsedProperty::FillOpacity(parse_input_to_parse_error(input)?)),
+ Ok(ParsedProperty::FillOpacity(parse_input(input)?)),
expanded_name!(svg "fill-rule") =>
- Ok(ParsedProperty::FillRule(parse_input_to_parse_error(input)?)),
+ Ok(ParsedProperty::FillRule(parse_input(input)?)),
expanded_name!(svg "filter") =>
- Ok(ParsedProperty::Filter(parse_input_to_parse_error(input)?)),
+ Ok(ParsedProperty::Filter(parse_input(input)?)),
expanded_name!(svg "flood-color") =>
- Ok(ParsedProperty::FloodColor(parse_input_to_parse_error(input)?)),
+ Ok(ParsedProperty::FloodColor(parse_input(input)?)),
expanded_name!(svg "flood-opacity") =>
- Ok(ParsedProperty::FloodOpacity(parse_input_to_parse_error(input)?)),
+ Ok(ParsedProperty::FloodOpacity(parse_input(input)?)),
expanded_name!(svg "font-family") =>
- Ok(ParsedProperty::FontFamily(parse_input_to_parse_error(input)?)),
+ Ok(ParsedProperty::FontFamily(parse_input(input)?)),
expanded_name!(svg "font-size") =>
- Ok(ParsedProperty::FontSize(parse_input_to_parse_error(input)?)),
+ Ok(ParsedProperty::FontSize(parse_input(input)?)),
expanded_name!(svg "font-stretch") =>
- Ok(ParsedProperty::FontStretch(parse_input_to_parse_error(input)?)),
+ Ok(ParsedProperty::FontStretch(parse_input(input)?)),
expanded_name!(svg "font-style") =>
- Ok(ParsedProperty::FontStyle(parse_input_to_parse_error(input)?)),
+ Ok(ParsedProperty::FontStyle(parse_input(input)?)),
expanded_name!(svg "font-variant") =>
- Ok(ParsedProperty::FontVariant(parse_input_to_parse_error(input)?)),
+ Ok(ParsedProperty::FontVariant(parse_input(input)?)),
expanded_name!(svg "font-weight") =>
- Ok(ParsedProperty::FontWeight(parse_input_to_parse_error(input)?)),
+ Ok(ParsedProperty::FontWeight(parse_input(input)?)),
expanded_name!(svg "letter-spacing") =>
- Ok(ParsedProperty::LetterSpacing(parse_input_to_parse_error(input)?)),
+ Ok(ParsedProperty::LetterSpacing(parse_input(input)?)),
expanded_name!(svg "lighting-color") =>
- Ok(ParsedProperty::LightingColor(parse_input_to_parse_error(input)?)),
+ Ok(ParsedProperty::LightingColor(parse_input(input)?)),
expanded_name!(svg "marker") => {
if accept_shorthands {
- Ok(ParsedProperty::Marker(parse_input_to_parse_error(input)?))
+ Ok(ParsedProperty::Marker(parse_input(input)?))
} else {
Err(ValueErrorKind::UnknownProperty)?
}
}
expanded_name!(svg "marker-end") =>
- Ok(ParsedProperty::MarkerEnd(parse_input_to_parse_error(input)?)),
+ Ok(ParsedProperty::MarkerEnd(parse_input(input)?)),
expanded_name!(svg "marker-mid") =>
- Ok(ParsedProperty::MarkerMid(parse_input_to_parse_error(input)?)),
+ Ok(ParsedProperty::MarkerMid(parse_input(input)?)),
expanded_name!(svg "marker-start") =>
- Ok(ParsedProperty::MarkerStart(parse_input_to_parse_error(input)?)),
+ Ok(ParsedProperty::MarkerStart(parse_input(input)?)),
expanded_name!(svg "mask") =>
- Ok(ParsedProperty::Mask(parse_input_to_parse_error(input)?)),
+ Ok(ParsedProperty::Mask(parse_input(input)?)),
expanded_name!(svg "opacity") =>
- Ok(ParsedProperty::Opacity(parse_input_to_parse_error(input)?)),
+ Ok(ParsedProperty::Opacity(parse_input(input)?)),
expanded_name!(svg "overflow") =>
- Ok(ParsedProperty::Overflow(parse_input_to_parse_error(input)?)),
+ Ok(ParsedProperty::Overflow(parse_input(input)?)),
expanded_name!(svg "shape-rendering") =>
- Ok(ParsedProperty::ShapeRendering(parse_input_to_parse_error(input)?)),
+ Ok(ParsedProperty::ShapeRendering(parse_input(input)?)),
expanded_name!(svg "stop-color") =>
- Ok(ParsedProperty::StopColor(parse_input_to_parse_error(input)?)),
+ Ok(ParsedProperty::StopColor(parse_input(input)?)),
expanded_name!(svg "stop-opacity") =>
- Ok(ParsedProperty::StopOpacity(parse_input_to_parse_error(input)?)),
+ Ok(ParsedProperty::StopOpacity(parse_input(input)?)),
expanded_name!(svg "stroke") =>
- Ok(ParsedProperty::Stroke(parse_input_to_parse_error(input)?)),
+ Ok(ParsedProperty::Stroke(parse_input(input)?)),
expanded_name!(svg "stroke-dasharray") =>
- Ok(ParsedProperty::StrokeDasharray(parse_input_to_parse_error(input)?)),
+ Ok(ParsedProperty::StrokeDasharray(parse_input(input)?)),
expanded_name!(svg "stroke-dashoffset") =>
- Ok(ParsedProperty::StrokeDashoffset(parse_input_to_parse_error(input)?)),
+ Ok(ParsedProperty::StrokeDashoffset(parse_input(input)?)),
expanded_name!(svg "stroke-linecap") =>
- Ok(ParsedProperty::StrokeLinecap(parse_input_to_parse_error(input)?)),
+ Ok(ParsedProperty::StrokeLinecap(parse_input(input)?)),
expanded_name!(svg "stroke-linejoin") =>
- Ok(ParsedProperty::StrokeLinejoin(parse_input_to_parse_error(input)?)),
+ Ok(ParsedProperty::StrokeLinejoin(parse_input(input)?)),
expanded_name!(svg "stroke-miterlimit") =>
- Ok(ParsedProperty::StrokeMiterlimit(parse_input_to_parse_error(input)?)),
+ Ok(ParsedProperty::StrokeMiterlimit(parse_input(input)?)),
expanded_name!(svg "stroke-opacity") =>
- Ok(ParsedProperty::StrokeOpacity(parse_input_to_parse_error(input)?)),
+ Ok(ParsedProperty::StrokeOpacity(parse_input(input)?)),
expanded_name!(svg "stroke-width") =>
- Ok(ParsedProperty::StrokeWidth(parse_input_to_parse_error(input)?)),
+ Ok(ParsedProperty::StrokeWidth(parse_input(input)?)),
expanded_name!(svg "text-anchor") =>
- Ok(ParsedProperty::TextAnchor(parse_input_to_parse_error(input)?)),
+ Ok(ParsedProperty::TextAnchor(parse_input(input)?)),
expanded_name!(svg "text-decoration") =>
- Ok(ParsedProperty::TextDecoration(parse_input_to_parse_error(input)?)),
+ Ok(ParsedProperty::TextDecoration(parse_input(input)?)),
expanded_name!(svg "text-rendering") =>
- Ok(ParsedProperty::TextRendering(parse_input_to_parse_error(input)?)),
+ Ok(ParsedProperty::TextRendering(parse_input(input)?)),
expanded_name!(svg "unicode-bidi") =>
- Ok(ParsedProperty::UnicodeBidi(parse_input_to_parse_error(input)?)),
+ Ok(ParsedProperty::UnicodeBidi(parse_input(input)?)),
expanded_name!(svg "visibility") =>
- Ok(ParsedProperty::Visibility(parse_input_to_parse_error(input)?)),
+ Ok(ParsedProperty::Visibility(parse_input(input)?)),
expanded_name!(svg "writing-mode") =>
- Ok(ParsedProperty::WritingMode(parse_input_to_parse_error(input)?)),
+ Ok(ParsedProperty::WritingMode(parse_input(input)?)),
_ => Err(ValueErrorKind::UnknownProperty)?
}
@@ -544,9 +550,7 @@ impl SpecifiedValues {
// be in error in that case.
Err(ParseError::V(v)) => {
rsvg_log!(
- "(ignoring invalid presentation attribute {:?}\n \
- value=\"{}\"\n \
- {})",
+ "(ignoring invalid presentation attribute {:?}\n value=\"{}\"\n {})",
attr.expanded(),
value,
v
@@ -561,8 +565,7 @@ impl SpecifiedValues {
t.to_css(&mut tok).unwrap(); // FIXME: what do we do with a fmt::Error?
rsvg_log!(
- "(ignoring invalid presentation attribute {:?}\n \
- value=\"{}\"\n \
+ "(ignoring invalid presentation attribute {:?}\n value=\"{}\"\n \
unexpected token '{}')",
attr.expanded(),
value,
@@ -575,8 +578,7 @@ impl SpecifiedValues {
..
})) => {
rsvg_log!(
- "(ignoring invalid presentation attribute {:?}\n \
- value=\"{}\"\n \
+ "(ignoring invalid presentation attribute {:?}\n value=\"{}\"\n \
unexpected end of input)",
attr.expanded(),
value,
@@ -588,8 +590,7 @@ impl SpecifiedValues {
..
})) => {
rsvg_log!(
- "(ignoring invalid presentation attribute {:?}\n \
- value=\"{}\"\n \
+ "(ignoring invalid presentation attribute {:?}\n value=\"{}\"\n \
unexpected error)",
attr.expanded(),
value,
@@ -601,9 +602,7 @@ impl SpecifiedValues {
..
})) => {
rsvg_log!(
- "(ignoring invalid presentation attribute {:?}\n \
- value=\"{}\"\n \
- {})",
+ "(ignoring invalid presentation attribute {:?}\n value=\"{}\"\n {})",
attr.expanded(),
value,
v
@@ -624,14 +623,14 @@ impl SpecifiedValues {
// xml:lang is a non-presentation attribute and as such cannot have the
// "inherit" value. So, we don't call parse_one_presentation_attribute()
// for it, but rather call its parser directly.
- self.xml_lang = SpecifiedValue::Specified(attr.parse_to_parse_error(value)?);
+ self.xml_lang = SpecifiedValue::Specified(attr.parse(value)?);
}
expanded_name!(svg "xml:space") => {
// xml:space is a non-presentation attribute and as such cannot have the
// "inherit" value. So, we don't call parse_one_presentation_attribute()
// for it, but rather call its parser directly.
- self.xml_space = SpecifiedValue::Specified(attr.parse_to_parse_error(value)?);
+ self.xml_space = SpecifiedValue::Specified(attr.parse(value)?);
}
_ => self.parse_one_presentation_attribute(attr, value)?,
@@ -674,11 +673,9 @@ impl SpecifiedValues {
}
// Parses the value for the type `T` of the property out of the Parser, including `inherit` values.
-fn parse_input_to_parse_error<'i, T>(
- input: &mut Parser<'i, '_>,
-) -> Result<SpecifiedValue<T>, CssParseError<'i>>
+fn parse_input<'i, T>(input: &mut Parser<'i, '_>) -> Result<SpecifiedValue<T>, CssParseError<'i>>
where
- T: Property<ComputedValues> + Clone + Default + ParseToParseError,
+ T: Property<ComputedValues> + Clone + Default + Parse,
{
if input
.try_parse(|p| p.expect_ident_matching("inherit"))
@@ -686,6 +683,6 @@ where
{
Ok(SpecifiedValue::Inherit)
} else {
- ParseToParseError::parse_to_parse_error(input).map(SpecifiedValue::Specified)
+ Parse::parse(input).map(SpecifiedValue::Specified)
}
}
diff --git a/rsvg_internals/src/property_bag.rs b/rsvg_internals/src/property_bag.rs
index 69239c29..685c45f5 100644
--- a/rsvg_internals/src/property_bag.rs
+++ b/rsvg_internals/src/property_bag.rs
@@ -75,8 +75,9 @@ impl<'a> PropertyBag<'a> {
// of https://www.w3.org/TR/xml-names11/
QualName::new(
prefix.map(Prefix::from),
- uri.map(Namespace::from).unwrap_or_else(|| element_ns.clone()),
- LocalName::from(localname)
+ uri.map(Namespace::from)
+ .unwrap_or_else(|| element_ns.clone()),
+ LocalName::from(localname),
)
};
@@ -135,20 +136,24 @@ mod tests {
#[test]
fn property_bag_with_namespaces() {
let attrs = [
- (CString::new("rx").unwrap(),
- CString::new("svg").unwrap(),
- CString::new("http://www.w3.org/2000/svg";).unwrap(),
- CString::new("1").unwrap()),
-
- (CString::new("ry").unwrap(),
- CString::new("svg").unwrap(),
- CString::new("http://www.w3.org/2000/svg";).unwrap(),
- CString::new("2").unwrap()),
-
- (CString::new("empty").unwrap(),
- CString::new("svg").unwrap(),
- CString::new("http://www.w3.org/2000/svg";).unwrap(),
- CString::new("").unwrap()),
+ (
+ CString::new("rx").unwrap(),
+ CString::new("svg").unwrap(),
+ CString::new("http://www.w3.org/2000/svg";).unwrap(),
+ CString::new("1").unwrap(),
+ ),
+ (
+ CString::new("ry").unwrap(),
+ CString::new("svg").unwrap(),
+ CString::new("http://www.w3.org/2000/svg";).unwrap(),
+ CString::new("2").unwrap(),
+ ),
+ (
+ CString::new("empty").unwrap(),
+ CString::new("svg").unwrap(),
+ CString::new("http://www.w3.org/2000/svg";).unwrap(),
+ CString::new("").unwrap(),
+ ),
];
let mut v: Vec<*const libc::c_char> = Vec::new();
diff --git a/rsvg_internals/src/property_defs.rs b/rsvg_internals/src/property_defs.rs
index ce18d08a..f72ce3c7 100644
--- a/rsvg_internals/src/property_defs.rs
+++ b/rsvg_internals/src/property_defs.rs
@@ -8,7 +8,7 @@ use crate::font_props::{FontSizeSpec, FontWeightSpec, LetterSpacingSpec, SingleF
use crate::iri::IRI;
use crate::length::*;
use crate::paint_server::PaintServer;
-use crate::parsers::ParseToParseError;
+use crate::parsers::Parse;
use crate::properties::ComputedValues;
use crate::property_macros::Property;
use crate::unit_interval::UnitInterval;
@@ -17,7 +17,7 @@ use crate::unit_interval::UnitInterval;
make_property!(
ComputedValues,
BaselineShift,
- default: Length::<Both>::parse_str_to_parse_error("0.0").unwrap(),
+ default: Length::<Both>::parse_str("0.0").unwrap(),
newtype: Length<Both>,
property_impl: {
impl Property<ComputedValues> for BaselineShift {
@@ -41,11 +41,11 @@ make_property!(
}
},
parse_impl: {
- impl ParseToParseError for BaselineShift {
+ impl Parse for BaselineShift {
// These values come from Inkscape's SP_CSS_BASELINE_SHIFT_(SUB/SUPER/BASELINE);
// see sp_style_merge_baseline_shift_from_parent()
- fn parse_to_parse_error<'i>(parser: &mut Parser<'i, '_>) -> Result<BaselineShift,
crate::error::CssParseError<'i>> {
- parser.try_parse(|p| Ok(BaselineShift(Length::<Both>::parse_to_parse_error(p)?)))
+ fn parse<'i>(parser: &mut Parser<'i, '_>) -> Result<BaselineShift,
crate::error::CssParseError<'i>> {
+ parser.try_parse(|p| Ok(BaselineShift(Length::<Both>::parse(p)?)))
.or_else(|_: CssParseError| {
Ok(parse_identifiers!(
parser,
@@ -66,7 +66,7 @@ make_property!(
ClipPath,
default: IRI::None,
inherits_automatically: false,
- newtype_parse_to_parse_error: IRI,
+ newtype_parse: IRI,
);
// https://www.w3.org/TR/SVG/masking.html#ClipRuleProperty
@@ -93,7 +93,7 @@ make_property!(
// surrounding text.
default: cssparser::RGBA::new(0, 0, 0, 0xff),
inherits_automatically: true,
- newtype_parse_to_parse_error: cssparser::RGBA,
+ newtype_parse: cssparser::RGBA,
);
// https://www.w3.org/TR/SVG11/painting.html#ColorInterpolationProperty
@@ -164,9 +164,9 @@ make_property!(
make_property!(
ComputedValues,
Fill,
- default: PaintServer::parse_str_to_parse_error("#000").unwrap(),
+ default: PaintServer::parse_str("#000").unwrap(),
inherits_automatically: true,
- newtype_parse_to_parse_error: PaintServer,
+ newtype_parse: PaintServer,
);
// https://www.w3.org/TR/SVG/painting.html#FillOpacityProperty
@@ -175,7 +175,7 @@ make_property!(
FillOpacity,
default: UnitInterval(1.0),
inherits_automatically: true,
- newtype_parse_to_parse_error: UnitInterval,
+ newtype_parse: UnitInterval,
);
// https://www.w3.org/TR/SVG/painting.html#FillRuleProperty
@@ -196,7 +196,7 @@ make_property!(
Filter,
default: IRI::None,
inherits_automatically: false,
- newtype_parse_to_parse_error: IRI,
+ newtype_parse: IRI,
);
// https://www.w3.org/TR/SVG/filters.html#FloodColorProperty
@@ -205,7 +205,7 @@ make_property!(
FloodColor,
default: cssparser::Color::RGBA(cssparser::RGBA::new(0, 0, 0, 0)),
inherits_automatically: false,
- newtype_parse_to_parse_error: cssparser::Color,
+ newtype_parse: cssparser::Color,
);
// https://www.w3.org/TR/SVG/filters.html#FloodOpacityProperty
@@ -214,7 +214,7 @@ make_property!(
FloodOpacity,
default: UnitInterval(1.0),
inherits_automatically: false,
- newtype_parse_to_parse_error: UnitInterval,
+ newtype_parse: UnitInterval,
);
// https://www.w3.org/TR/SVG/text.html#FontFamilyProperty
@@ -223,14 +223,14 @@ make_property!(
FontFamily,
default: SingleFontFamily("Times New Roman".to_string()),
inherits_automatically: true,
- newtype_parse_to_parse_error: SingleFontFamily,
+ newtype_parse: SingleFontFamily,
);
// https://www.w3.org/TR/SVG/text.html#FontSizeProperty
make_property!(
ComputedValues,
FontSize,
- default: FontSizeSpec::Value(Length::<Both>::parse_str_to_parse_error("12.0").unwrap()),
+ default: FontSizeSpec::Value(Length::<Both>::parse_str("12.0").unwrap()),
newtype_parse: FontSizeSpec,
property_impl: {
impl Property<ComputedValues> for FontSize {
@@ -297,7 +297,7 @@ make_property!(
FontWeight,
default: FontWeightSpec::Normal,
inherits_automatically: true,
- newtype_parse_to_parse_error: FontWeightSpec,
+ newtype_parse: FontWeightSpec,
);
// https://www.w3.org/TR/SVG/text.html#LetterSpacingProperty
@@ -325,7 +325,7 @@ make_property!(
LightingColor,
default: cssparser::Color::RGBA(cssparser::RGBA::new(255, 255, 255, 255)),
inherits_automatically: false,
- newtype_parse_to_parse_error: cssparser::Color,
+ newtype_parse: cssparser::Color,
);
make_property!(
@@ -333,7 +333,7 @@ make_property!(
Marker,
default: IRI::None,
inherits_automatically: true,
- newtype_parse_to_parse_error: IRI,
+ newtype_parse: IRI,
);
// https://www.w3.org/TR/SVG/painting.html#MarkerEndProperty
@@ -342,7 +342,7 @@ make_property!(
MarkerEnd,
default: IRI::None,
inherits_automatically: true,
- newtype_parse_to_parse_error: IRI,
+ newtype_parse: IRI,
);
// https://www.w3.org/TR/SVG/painting.html#MarkerMidProperty
@@ -351,7 +351,7 @@ make_property!(
MarkerMid,
default: IRI::None,
inherits_automatically: true,
- newtype_parse_to_parse_error: IRI,
+ newtype_parse: IRI,
);
// https://www.w3.org/TR/SVG/painting.html#MarkerStartProperty
@@ -360,7 +360,7 @@ make_property!(
MarkerStart,
default: IRI::None,
inherits_automatically: true,
- newtype_parse_to_parse_error: IRI,
+ newtype_parse: IRI,
);
// https://www.w3.org/TR/SVG/masking.html#MaskProperty
@@ -369,7 +369,7 @@ make_property!(
Mask,
default: IRI::None,
inherits_automatically: false,
- newtype_parse_to_parse_error: IRI,
+ newtype_parse: IRI,
);
// https://www.w3.org/TR/SVG/masking.html#OpacityProperty
@@ -378,7 +378,7 @@ make_property!(
Opacity,
default: UnitInterval(1.0),
inherits_automatically: false,
- newtype_parse_to_parse_error: UnitInterval,
+ newtype_parse: UnitInterval,
);
// https://www.w3.org/TR/SVG/masking.html#OverflowProperty
@@ -415,7 +415,7 @@ make_property!(
StopColor,
default: cssparser::Color::RGBA(cssparser::RGBA::new(0, 0, 0, 255)),
inherits_automatically: false,
- newtype_parse_to_parse_error: cssparser::Color,
+ newtype_parse: cssparser::Color,
);
// https://www.w3.org/TR/SVG/pservers.html#StopOpacityProperty
@@ -424,7 +424,7 @@ make_property!(
StopOpacity,
default: UnitInterval(1.0),
inherits_automatically: false,
- newtype_parse_to_parse_error: UnitInterval,
+ newtype_parse: UnitInterval,
);
// https://www.w3.org/TR/SVG/painting.html#StrokeProperty
@@ -433,7 +433,7 @@ make_property!(
Stroke,
default: PaintServer::None,
inherits_automatically: true,
- newtype_parse_to_parse_error: PaintServer,
+ newtype_parse: PaintServer,
);
// https://www.w3.org/TR/SVG/painting.html#StrokeDasharrayProperty
@@ -442,7 +442,7 @@ make_property!(
StrokeDasharray,
default: Dasharray::default(),
inherits_automatically: true,
- newtype_parse_to_parse_error: Dasharray,
+ newtype_parse: Dasharray,
);
// https://www.w3.org/TR/SVG/painting.html#StrokeDashoffsetProperty
@@ -451,7 +451,7 @@ make_property!(
StrokeDashoffset,
default: Length::<Both>::default(),
inherits_automatically: true,
- newtype_parse_to_parse_error: Length<Both>,
+ newtype_parse: Length<Both>,
);
// https://www.w3.org/TR/SVG/painting.html#StrokeLinecapProperty
@@ -486,7 +486,7 @@ make_property!(
StrokeMiterlimit,
default: 4f64,
inherits_automatically: true,
- newtype_parse_to_parse_error: f64,
+ newtype_parse: f64,
);
// https://www.w3.org/TR/SVG/painting.html#StrokeOpacityProperty
@@ -495,16 +495,16 @@ make_property!(
StrokeOpacity,
default: UnitInterval(1.0),
inherits_automatically: true,
- newtype_parse_to_parse_error: UnitInterval,
+ newtype_parse: UnitInterval,
);
// https://www.w3.org/TR/SVG/painting.html#StrokeWidthProperty
make_property!(
ComputedValues,
StrokeWidth,
- default: Length::<Both>::parse_str_to_parse_error("1.0").unwrap(),
+ default: Length::<Both>::parse_str("1.0").unwrap(),
inherits_automatically: true,
- newtype_parse_to_parse_error: Length::<Both>,
+ newtype_parse: Length::<Both>,
);
// https://www.w3.org/TR/SVG/text.html#TextAnchorProperty
@@ -533,8 +533,8 @@ make_property!(
}
parse_impl: {
- impl ParseToParseError for TextDecoration {
- fn parse_to_parse_error<'i>(parser: &mut Parser<'i, '_>) -> Result<TextDecoration,
CssParseError<'i>> {
+ impl Parse for TextDecoration {
+ fn parse<'i>(parser: &mut Parser<'i, '_>) -> Result<TextDecoration, CssParseError<'i>> {
let mut overline = false;
let mut underline = false;
let mut strike = false;
@@ -569,7 +569,7 @@ make_property!(
#[test]
fn parses_text_decoration() {
assert_eq!(
- TextDecoration::parse_str_to_parse_error("none").unwrap(),
+ TextDecoration::parse_str("none").unwrap(),
TextDecoration {
overline: false,
underline: false,
@@ -578,7 +578,7 @@ fn parses_text_decoration() {
);
assert_eq!(
- TextDecoration::parse_str_to_parse_error("overline").unwrap(),
+ TextDecoration::parse_str("overline").unwrap(),
TextDecoration {
overline: true,
underline: false,
@@ -587,7 +587,7 @@ fn parses_text_decoration() {
);
assert_eq!(
- TextDecoration::parse_str_to_parse_error("underline").unwrap(),
+ TextDecoration::parse_str("underline").unwrap(),
TextDecoration {
overline: false,
underline: true,
@@ -596,7 +596,7 @@ fn parses_text_decoration() {
);
assert_eq!(
- TextDecoration::parse_str_to_parse_error("line-through").unwrap(),
+ TextDecoration::parse_str("line-through").unwrap(),
TextDecoration {
overline: false,
underline: false,
@@ -605,7 +605,7 @@ fn parses_text_decoration() {
);
assert_eq!(
- TextDecoration::parse_str_to_parse_error("underline overline").unwrap(),
+ TextDecoration::parse_str("underline overline").unwrap(),
TextDecoration {
overline: true,
underline: true,
@@ -613,7 +613,7 @@ fn parses_text_decoration() {
}
);
- assert!(TextDecoration::parse_str_to_parse_error("airline").is_err())
+ assert!(TextDecoration::parse_str("airline").is_err())
}
// https://www.w3.org/TR/SVG/painting.html#TextRenderingProperty
@@ -688,8 +688,8 @@ make_property!(
inherits_automatically: true,
newtype: String,
parse_impl: {
- impl ParseToParseError for XmlLang {
- fn parse_to_parse_error<'i>(
+ impl Parse for XmlLang {
+ fn parse<'i>(
parser: &mut Parser<'i, '_>,
) -> Result<XmlLang, CssParseError<'i>> {
Ok(XmlLang(parser.expect_ident()?.to_string()))
@@ -702,11 +702,11 @@ make_property!(
#[test]
fn parses_xml_lang() {
assert_eq!(
- XmlLang::parse_str_to_parse_error("es-MX").unwrap(),
+ XmlLang::parse_str("es-MX").unwrap(),
XmlLang("es-MX".to_string())
);
- assert!(XmlLang::parse_str_to_parse_error("").is_err());
+ assert!(XmlLang::parse_str("").is_err());
}
make_property!(
diff --git a/rsvg_internals/src/property_macros.rs b/rsvg_internals/src/property_macros.rs
index a24d1a2a..33211fca 100644
--- a/rsvg_internals/src/property_macros.rs
+++ b/rsvg_internals/src/property_macros.rs
@@ -45,8 +45,8 @@ macro_rules! make_property {
impl_default!($name, $name::$default);
impl_property!($computed_values_type, $name, $inherits_automatically);
- impl crate::parsers::ParseToParseError for $name {
- fn parse_to_parse_error<'i>(parser: &mut ::cssparser::Parser<'i, '_>) -> Result<$name,
crate::error::CssParseError<'i>> {
+ impl crate::parsers::Parse for $name {
+ fn parse<'i>(parser: &mut ::cssparser::Parser<'i, '_>) -> Result<$name,
crate::error::CssParseError<'i>> {
Ok(parse_identifiers!(
parser,
$($str_prop => $name::$variant,)+
@@ -68,31 +68,12 @@ macro_rules! make_property {
impl_property!($computed_values_type, $name, $inherits_automatically);
impl crate::parsers::Parse for $name {
- fn parse(parser: &mut ::cssparser::Parser<'_, '_>) -> Result<$name,
crate::error::ValueErrorKind> {
+ fn parse<'i>(parser: &mut ::cssparser::Parser<'i, '_>) -> Result<$name,
crate::error::CssParseError<'i>> {
Ok($name(<$type as crate::parsers::Parse>::parse(parser)?))
}
}
};
- ($computed_values_type: ty,
- $name: ident,
- default: $default: expr,
- inherits_automatically: $inherits_automatically: expr,
- newtype_parse_to_parse_error: $type: ty,
- ) => {
- #[derive(Debug, Clone, PartialEq)]
- pub struct $name(pub $type);
-
- impl_default!($name, $name($default));
- impl_property!($computed_values_type, $name, $inherits_automatically);
-
- impl crate::parsers::ParseToParseError for $name {
- fn parse_to_parse_error<'i>(parser: &mut ::cssparser::Parser<'i, '_>) -> Result<$name,
crate::error::CssParseError<'i>> {
- Ok($name(<$type as crate::parsers::ParseToParseError>::parse_to_parse_error(parser)?))
- }
- }
- };
-
($computed_values_type: ty,
$name: ident,
default: $default: expr,
@@ -106,9 +87,9 @@ macro_rules! make_property {
$prop
- impl crate::parsers::ParseToParseError for $name {
- fn parse_to_parse_error<'i>(parser: &mut ::cssparser::Parser<'i, '_>) -> Result<$name,
crate::error::CssParseError<'i>> {
- Ok($name(<$type as crate::parsers::ParseToParseError>::parse_to_parse_error(parser)?))
+ impl crate::parsers::Parse for $name {
+ fn parse<'i>(parser: &mut ::cssparser::Parser<'i, '_>) -> Result<$name,
crate::error::CssParseError<'i>> {
+ Ok($name(<$type as crate::parsers::Parse>::parse(parser)?))
}
}
};
@@ -194,7 +175,7 @@ macro_rules! impl_property {
mod tests {
use super::*;
- use crate::parsers::ParseToParseError;
+ use crate::parsers::Parse;
use cssparser::RGBA;
#[test]
@@ -213,8 +194,8 @@ mod tests {
assert_eq!(<Foo as Default>::default(), Foo::Def);
assert_eq!(<Foo as Property<()>>::inherits_automatically(), true);
- assert!(<Foo as ParseToParseError>::parse_str_to_parse_error("blargh").is_err());
- assert_eq!(<Foo as ParseToParseError>::parse_str_to_parse_error("bar"), Ok(Foo::Bar));
+ assert!(<Foo as Parse>::parse_str("blargh").is_err());
+ assert_eq!(<Foo as Parse>::parse_str("bar"), Ok(Foo::Bar));
}
#[test]
@@ -243,7 +224,7 @@ mod tests {
}
let color = RGBA::new(1, 1, 1, 1);
- let a = <AddColor as ParseToParseError>::parse_str_to_parse_error("#02030405").unwrap();
+ let a = <AddColor as Parse>::parse_str("#02030405").unwrap();
let b = a.compute(&color);
assert_eq!(b, AddColor(RGBA::new(3, 4, 5, 6)));
diff --git a/rsvg_internals/src/shapes.rs b/rsvg_internals/src/shapes.rs
index 1c9f142d..bb495696 100644
--- a/rsvg_internals/src/shapes.rs
+++ b/rsvg_internals/src/shapes.rs
@@ -3,8 +3,8 @@
use cairo;
use markup5ever::{expanded_name, local_name, namespace_url, ns};
-use std::rc::Rc;
use std::ops::Deref;
+use std::rc::Rc;
use crate::bbox::BoundingBox;
use crate::drawing_ctx::DrawingCtx;
@@ -12,7 +12,7 @@ use crate::error::*;
use crate::length::*;
use crate::marker;
use crate::node::*;
-use crate::parsers::{optional_comma, ParseToParseError, ParseValueToParseError};
+use crate::parsers::{optional_comma, Parse, ParseValue};
use crate::path_builder::*;
use crate::path_parser;
use crate::properties::ComputedValues;
@@ -65,10 +65,7 @@ pub struct Shape {
impl Shape {
fn new(builder: Rc<PathBuilder>, markers: Markers) -> Shape {
- Shape {
- builder,
- markers,
- }
+ Shape { builder, markers }
}
fn draw(
@@ -177,8 +174,7 @@ impl NodeTrait for Path {
) -> Result<BoundingBox, RenderingError> {
if let Some(builder) = self.builder.as_ref() {
let values = cascaded.get();
- Shape::new(builder.clone(), Markers::Yes)
- .draw(node, values, draw_ctx, clipping)
+ Shape::new(builder.clone(), Markers::Yes).draw(node, values, draw_ctx, clipping)
} else {
Ok(draw_ctx.empty_bbox())
}
@@ -198,14 +194,14 @@ impl Deref for Points {
// Parse a list-of-points as for polyline and polygon elements
// https://www.w3.org/TR/SVG/shapes.html#PointsBNF
-impl ParseToParseError for Points {
- fn parse_to_parse_error<'i>(parser: &mut Parser<'i, '_>) -> Result<Points, CssParseError<'i>> {
+impl Parse for Points {
+ fn parse<'i>(parser: &mut Parser<'i, '_>) -> Result<Points, CssParseError<'i>> {
let mut v = Vec::new();
loop {
- let x = f64::parse_to_parse_error(parser)?;
+ let x = f64::parse(parser)?;
optional_comma(parser);
- let y = f64::parse_to_parse_error(parser)?;
+ let y = f64::parse(parser)?;
v.push((x, y));
@@ -252,7 +248,7 @@ impl NodeTrait for Polygon {
fn set_atts(&mut self, _: Option<&RsvgNode>, pbag: &PropertyBag<'_>) -> NodeResult {
for (attr, value) in pbag.iter() {
if attr.expanded() == expanded_name!(svg "points") {
- self.points = attr.parse_to_parse_error(value).map(Some)?;
+ self.points = attr.parse(value).map(Some)?;
}
}
@@ -281,7 +277,7 @@ impl NodeTrait for Polyline {
fn set_atts(&mut self, _: Option<&RsvgNode>, pbag: &PropertyBag<'_>) -> NodeResult {
for (attr, value) in pbag.iter() {
if attr.expanded() == expanded_name!(svg "points") {
- self.points = attr.parse_to_parse_error(value).map(Some)?;
+ self.points = attr.parse(value).map(Some)?;
}
}
@@ -296,8 +292,11 @@ impl NodeTrait for Polyline {
clipping: bool,
) -> Result<BoundingBox, RenderingError> {
let values = cascaded.get();
- Shape::new(Rc::new(make_poly(self.points.as_ref(), false)), Markers::Yes)
- .draw(node, values, draw_ctx, clipping)
+ Shape::new(
+ Rc::new(make_poly(self.points.as_ref(), false)),
+ Markers::Yes,
+ )
+ .draw(node, values, draw_ctx, clipping)
}
}
@@ -313,10 +312,10 @@ impl NodeTrait for Line {
fn set_atts(&mut self, _: Option<&RsvgNode>, pbag: &PropertyBag<'_>) -> NodeResult {
for (attr, value) in pbag.iter() {
match attr.expanded() {
- expanded_name!(svg "x1") => self.x1 = attr.parse_to_parse_error(value)?,
- expanded_name!(svg "y1") => self.y1 = attr.parse_to_parse_error(value)?,
- expanded_name!(svg "x2") => self.x2 = attr.parse_to_parse_error(value)?,
- expanded_name!(svg "y2") => self.y2 = attr.parse_to_parse_error(value)?,
+ expanded_name!(svg "x1") => self.x1 = attr.parse(value)?,
+ expanded_name!(svg "y1") => self.y1 = attr.parse(value)?,
+ expanded_name!(svg "x2") => self.x2 = attr.parse(value)?,
+ expanded_name!(svg "y2") => self.y2 = attr.parse(value)?,
_ => (),
}
}
@@ -332,17 +331,16 @@ impl NodeTrait for Line {
clipping: bool,
) -> Result<BoundingBox, RenderingError> {
let values = cascaded.get();
- Shape::new(Rc::new(self.make_path_builder(values, draw_ctx)), Markers::Yes)
- .draw(node, values, draw_ctx, clipping)
+ Shape::new(
+ Rc::new(self.make_path_builder(values, draw_ctx)),
+ Markers::Yes,
+ )
+ .draw(node, values, draw_ctx, clipping)
}
}
impl Line {
- fn make_path_builder(
- &self,
- values: &ComputedValues,
- draw_ctx: &mut DrawingCtx,
- ) -> PathBuilder {
+ fn make_path_builder(&self, values: &ComputedValues, draw_ctx: &mut DrawingCtx) -> PathBuilder {
let mut builder = PathBuilder::new();
let params = draw_ctx.get_view_params();
@@ -375,24 +373,24 @@ impl NodeTrait for Rect {
fn set_atts(&mut self, _: Option<&RsvgNode>, pbag: &PropertyBag<'_>) -> NodeResult {
for (attr, value) in pbag.iter() {
match attr.expanded() {
- expanded_name!(svg "x") => self.x = attr.parse_to_parse_error(value)?,
- expanded_name!(svg "y") => self.y = attr.parse_to_parse_error(value)?,
+ expanded_name!(svg "x") => self.x = attr.parse(value)?,
+ expanded_name!(svg "y") => self.y = attr.parse(value)?,
expanded_name!(svg "width") => {
self.w =
- attr.parse_to_parse_error_and_validate(value,
Length::<Horizontal>::check_nonnegative)?
+ attr.parse_and_validate(value, Length::<Horizontal>::check_nonnegative)?
}
expanded_name!(svg "height") => {
self.h =
- attr.parse_to_parse_error_and_validate(value, Length::<Vertical>::check_nonnegative)?
+ attr.parse_and_validate(value, Length::<Vertical>::check_nonnegative)?
}
expanded_name!(svg "rx") => {
self.rx = attr
- .parse_to_parse_error_and_validate(value, Length::<Horizontal>::check_nonnegative)
+ .parse_and_validate(value, Length::<Horizontal>::check_nonnegative)
.map(Some)?
}
expanded_name!(svg "ry") => {
self.ry = attr
- .parse_to_parse_error_and_validate(value, Length::<Vertical>::check_nonnegative)
+ .parse_and_validate(value, Length::<Vertical>::check_nonnegative)
.map(Some)?
}
_ => (),
@@ -410,17 +408,16 @@ impl NodeTrait for Rect {
clipping: bool,
) -> Result<BoundingBox, RenderingError> {
let values = cascaded.get();
- Shape::new(Rc::new(self.make_path_builder(values, draw_ctx)), Markers::No)
- .draw(node, values, draw_ctx, clipping)
+ Shape::new(
+ Rc::new(self.make_path_builder(values, draw_ctx)),
+ Markers::No,
+ )
+ .draw(node, values, draw_ctx, clipping)
}
}
impl Rect {
- fn make_path_builder(
- &self,
- values: &ComputedValues,
- draw_ctx: &mut DrawingCtx,
- ) -> PathBuilder {
+ fn make_path_builder(&self, values: &ComputedValues, draw_ctx: &mut DrawingCtx) -> PathBuilder {
let params = draw_ctx.get_view_params();
let x = self.x.normalize(values, ¶ms);
@@ -603,10 +600,10 @@ impl NodeTrait for Circle {
fn set_atts(&mut self, _: Option<&RsvgNode>, pbag: &PropertyBag<'_>) -> NodeResult {
for (attr, value) in pbag.iter() {
match attr.expanded() {
- expanded_name!(svg "cx") => self.cx = attr.parse_to_parse_error(value)?,
- expanded_name!(svg "cy") => self.cy = attr.parse_to_parse_error(value)?,
+ expanded_name!(svg "cx") => self.cx = attr.parse(value)?,
+ expanded_name!(svg "cy") => self.cy = attr.parse(value)?,
expanded_name!(svg "r") => {
- self.r = attr.parse_to_parse_error_and_validate(value,
Length::<Both>::check_nonnegative)?
+ self.r = attr.parse_and_validate(value, Length::<Both>::check_nonnegative)?
}
_ => (),
}
@@ -623,17 +620,16 @@ impl NodeTrait for Circle {
clipping: bool,
) -> Result<BoundingBox, RenderingError> {
let values = cascaded.get();
- Shape::new(Rc::new(self.make_path_builder(values, draw_ctx)), Markers::No)
- .draw(node, values, draw_ctx, clipping)
+ Shape::new(
+ Rc::new(self.make_path_builder(values, draw_ctx)),
+ Markers::No,
+ )
+ .draw(node, values, draw_ctx, clipping)
}
}
impl Circle {
- fn make_path_builder(
- &self,
- values: &ComputedValues,
- draw_ctx: &mut DrawingCtx,
- ) -> PathBuilder {
+ fn make_path_builder(&self, values: &ComputedValues, draw_ctx: &mut DrawingCtx) -> PathBuilder {
let params = draw_ctx.get_view_params();
let cx = self.cx.normalize(values, ¶ms);
@@ -656,15 +652,15 @@ impl NodeTrait for Ellipse {
fn set_atts(&mut self, _: Option<&RsvgNode>, pbag: &PropertyBag<'_>) -> NodeResult {
for (attr, value) in pbag.iter() {
match attr.expanded() {
- expanded_name!(svg "cx") => self.cx = attr.parse_to_parse_error(value)?,
- expanded_name!(svg "cy") => self.cy = attr.parse_to_parse_error(value)?,
+ expanded_name!(svg "cx") => self.cx = attr.parse(value)?,
+ expanded_name!(svg "cy") => self.cy = attr.parse(value)?,
expanded_name!(svg "rx") => {
self.rx =
- attr.parse_to_parse_error_and_validate(value,
Length::<Horizontal>::check_nonnegative)?
+ attr.parse_and_validate(value, Length::<Horizontal>::check_nonnegative)?
}
expanded_name!(svg "ry") => {
self.ry =
- attr.parse_to_parse_error_and_validate(value, Length::<Vertical>::check_nonnegative)?
+ attr.parse_and_validate(value, Length::<Vertical>::check_nonnegative)?
}
_ => (),
}
@@ -681,17 +677,16 @@ impl NodeTrait for Ellipse {
clipping: bool,
) -> Result<BoundingBox, RenderingError> {
let values = cascaded.get();
- Shape::new(Rc::new(self.make_path_builder(values, draw_ctx)), Markers::No)
- .draw(node, values, draw_ctx, clipping)
+ Shape::new(
+ Rc::new(self.make_path_builder(values, draw_ctx)),
+ Markers::No,
+ )
+ .draw(node, values, draw_ctx, clipping)
}
}
impl Ellipse {
- fn make_path_builder(
- &self,
- values: &ComputedValues,
- draw_ctx: &mut DrawingCtx,
- ) -> PathBuilder {
+ fn make_path_builder(&self, values: &ComputedValues, draw_ctx: &mut DrawingCtx) -> PathBuilder {
let params = draw_ctx.get_view_params();
let cx = self.cx.normalize(values, ¶ms);
@@ -709,32 +704,32 @@ mod tests {
#[test]
fn parses_points() {
- assert_eq!(Points::parse_str_to_parse_error(" 1 2 "), Ok(Points(vec![(1.0, 2.0)])));
+ assert_eq!(Points::parse_str(" 1 2 "), Ok(Points(vec![(1.0, 2.0)])));
assert_eq!(
- Points::parse_str_to_parse_error("1 2 3 4"),
+ Points::parse_str("1 2 3 4"),
Ok(Points(vec![(1.0, 2.0), (3.0, 4.0)]))
);
assert_eq!(
- Points::parse_str_to_parse_error("1,2,3,4"),
+ Points::parse_str("1,2,3,4"),
Ok(Points(vec![(1.0, 2.0), (3.0, 4.0)]))
);
assert_eq!(
- Points::parse_str_to_parse_error("1,2 3,4"),
+ Points::parse_str("1,2 3,4"),
Ok(Points(vec![(1.0, 2.0), (3.0, 4.0)]))
);
assert_eq!(
- Points::parse_str_to_parse_error("1,2 -3,4"),
+ Points::parse_str("1,2 -3,4"),
Ok(Points(vec![(1.0, 2.0), (-3.0, 4.0)]))
);
assert_eq!(
- Points::parse_str_to_parse_error("1,2,-3,4"),
+ Points::parse_str("1,2,-3,4"),
Ok(Points(vec![(1.0, 2.0), (-3.0, 4.0)]))
);
}
#[test]
fn errors_on_invalid_points() {
- assert!(Points::parse_str_to_parse_error("-1-2-3-4").is_err());
- assert!(Points::parse_str_to_parse_error("1 2-3,-4").is_err());
+ assert!(Points::parse_str("-1-2-3-4").is_err());
+ assert!(Points::parse_str("1 2-3,-4").is_err());
}
}
diff --git a/rsvg_internals/src/structure.rs b/rsvg_internals/src/structure.rs
index 9097b418..974f2573 100644
--- a/rsvg_internals/src/structure.rs
+++ b/rsvg_internals/src/structure.rs
@@ -11,7 +11,7 @@ use crate::error::*;
use crate::float_eq_cairo::ApproxEqCairo;
use crate::length::*;
use crate::node::*;
-use crate::parsers::{ParseToParseError, ParseValueToParseError};
+use crate::parsers::{Parse, ParseValue};
use crate::properties::ComputedValues;
use crate::property_bag::PropertyBag;
use crate::property_defs::Overflow;
@@ -149,16 +149,16 @@ impl Svg {
// these defaults are per the spec
let x = self
.x
- .unwrap_or_else(|| Length::<Horizontal>::parse_str_to_parse_error("0").unwrap());
+ .unwrap_or_else(|| Length::<Horizontal>::parse_str("0").unwrap());
let y = self
.y
- .unwrap_or_else(|| Length::<Vertical>::parse_str_to_parse_error("0").unwrap());
+ .unwrap_or_else(|| Length::<Vertical>::parse_str("0").unwrap());
let w = self
.w
- .unwrap_or_else(|| Length::<Horizontal>::parse_str_to_parse_error("100%").unwrap());
+ .unwrap_or_else(|| Length::<Horizontal>::parse_str("100%").unwrap());
let h = self
.h
- .unwrap_or_else(|| Length::<Vertical>::parse_str_to_parse_error("100%").unwrap());
+ .unwrap_or_else(|| Length::<Vertical>::parse_str("100%").unwrap());
(x, y, w, h)
}
@@ -184,19 +184,20 @@ impl NodeTrait for Svg {
for (attr, value) in pbag.iter() {
match attr.expanded() {
expanded_name!(svg "preserveAspectRatio") => {
- self.preserve_aspect_ratio = attr.parse_to_parse_error(value)?
+ self.preserve_aspect_ratio = attr.parse(value)?
}
- expanded_name!(svg "x") if is_inner_svg => self.x = Some(attr.parse_to_parse_error(value)?),
- expanded_name!(svg "y") if is_inner_svg => self.y = Some(attr.parse_to_parse_error(value)?),
+ expanded_name!(svg "x") if is_inner_svg => self.x = Some(attr.parse(value)?),
+ expanded_name!(svg "y") if is_inner_svg => self.y = Some(attr.parse(value)?),
expanded_name!(svg "width") => {
- self.w =
- Some(attr.parse_to_parse_error_and_validate(value,
Length::<Horizontal>::check_nonnegative)?)
+ self.w = Some(
+ attr.parse_and_validate(value, Length::<Horizontal>::check_nonnegative)?,
+ )
}
expanded_name!(svg "height") => {
self.h =
- Some(attr.parse_to_parse_error_and_validate(value,
Length::<Vertical>::check_nonnegative)?)
+ Some(attr.parse_and_validate(value, Length::<Vertical>::check_nonnegative)?)
}
- expanded_name!(svg "viewBox") => self.vbox = attr.parse_to_parse_error(value).map(Some)?,
+ expanded_name!(svg "viewBox") => self.vbox = attr.parse(value).map(Some)?,
_ => (),
}
}
@@ -278,16 +279,16 @@ impl NodeTrait for Use {
expanded_name!(xlink "href") => {
self.link = Some(Fragment::parse(value).attribute(attr)?)
}
- expanded_name!(svg "x") => self.x = attr.parse_to_parse_error(value)?,
- expanded_name!(svg "y") => self.y = attr.parse_to_parse_error(value)?,
+ expanded_name!(svg "x") => self.x = attr.parse(value)?,
+ expanded_name!(svg "y") => self.y = attr.parse(value)?,
expanded_name!(svg "width") => {
self.w = attr
- .parse_to_parse_error_and_validate(value, Length::<Horizontal>::check_nonnegative)
+ .parse_and_validate(value, Length::<Horizontal>::check_nonnegative)
.map(Some)?
}
expanded_name!(svg "height") => {
self.h = attr
- .parse_to_parse_error_and_validate(value, Length::<Vertical>::check_nonnegative)
+ .parse_and_validate(value, Length::<Vertical>::check_nonnegative)
.map(Some)?
}
_ => (),
@@ -362,11 +363,11 @@ impl NodeTrait for Use {
let nw = self
.w
- .unwrap_or_else(|| Length::<Horizontal>::parse_str_to_parse_error("100%").unwrap())
+ .unwrap_or_else(|| Length::<Horizontal>::parse_str("100%").unwrap())
.normalize(values, ¶ms);
let nh = self
.h
- .unwrap_or_else(|| Length::<Vertical>::parse_str_to_parse_error("100%").unwrap())
+ .unwrap_or_else(|| Length::<Vertical>::parse_str("100%").unwrap())
.normalize(values, ¶ms);
// width or height set to 0 disables rendering of the element
@@ -427,9 +428,9 @@ impl NodeTrait for Symbol {
for (attr, value) in pbag.iter() {
match attr.expanded() {
expanded_name!(svg "preserveAspectRatio") => {
- self.preserve_aspect_ratio = attr.parse_to_parse_error(value)?
+ self.preserve_aspect_ratio = attr.parse(value)?
}
- expanded_name!(svg "viewBox") => self.vbox = attr.parse_to_parse_error(value).map(Some)?,
+ expanded_name!(svg "viewBox") => self.vbox = attr.parse(value).map(Some)?,
_ => (),
}
}
diff --git a/rsvg_internals/src/style.rs b/rsvg_internals/src/style.rs
index 8c794044..296ab15f 100644
--- a/rsvg_internals/src/style.rs
+++ b/rsvg_internals/src/style.rs
@@ -5,7 +5,7 @@ use markup5ever::{expanded_name, local_name, namespace_url, ns};
use crate::error::*;
use crate::node::{NodeResult, NodeTrait, RsvgNode};
-use crate::parsers::{ParseToParseError, ParseValueToParseError};
+use crate::parsers::{Parse, ParseValue};
use crate::property_bag::PropertyBag;
/// Represents the syntax used in the <style> node.
@@ -19,8 +19,8 @@ pub enum StyleType {
TextCss,
}
-impl ParseToParseError for StyleType {
- fn parse_to_parse_error<'i>(parser: &mut Parser<'i, '_>) -> Result<StyleType, CssParseError<'i>> {
+impl Parse for StyleType {
+ fn parse<'i>(parser: &mut Parser<'i, '_>) -> Result<StyleType, CssParseError<'i>> {
parser.expect_ident_matching("text/css")?;
Ok(StyleType::TextCss)
}
@@ -45,7 +45,7 @@ impl NodeTrait for Style {
fn set_atts(&mut self, _: Option<&RsvgNode>, pbag: &PropertyBag<'_>) -> NodeResult {
for (attr, value) in pbag.iter() {
if attr.expanded() == expanded_name!(svg "type") {
- self.type_ = Some(attr.parse_to_parse_error(value)?);
+ self.type_ = Some(attr.parse(value)?);
}
}
diff --git a/rsvg_internals/src/text.rs b/rsvg_internals/src/text.rs
index c95bb4bd..ff10295f 100644
--- a/rsvg_internals/src/text.rs
+++ b/rsvg_internals/src/text.rs
@@ -15,7 +15,7 @@ use crate::float_eq_cairo::ApproxEqCairo;
use crate::font_props::FontWeightSpec;
use crate::length::*;
use crate::node::{CascadedValues, NodeResult, NodeTrait, NodeType, RsvgNode};
-use crate::parsers::ParseValueToParseError;
+use crate::parsers::ParseValue;
use crate::properties::ComputedValues;
use crate::property_bag::PropertyBag;
use crate::property_defs::{
@@ -602,10 +602,10 @@ impl NodeTrait for Text {
fn set_atts(&mut self, _: Option<&RsvgNode>, pbag: &PropertyBag<'_>) -> NodeResult {
for (attr, value) in pbag.iter() {
match attr.expanded() {
- expanded_name!(svg "x") => self.x = attr.parse_to_parse_error(value)?,
- expanded_name!(svg "y") => self.y = attr.parse_to_parse_error(value)?,
- expanded_name!(svg "dx") => self.dx = attr.parse_to_parse_error(value).map(Some)?,
- expanded_name!(svg "dy") => self.dy = attr.parse_to_parse_error(value).map(Some)?,
+ expanded_name!(svg "x") => self.x = attr.parse(value)?,
+ expanded_name!(svg "y") => self.y = attr.parse(value)?,
+ expanded_name!(svg "dx") => self.dx = attr.parse(value).map(Some)?,
+ expanded_name!(svg "dy") => self.dy = attr.parse(value).map(Some)?,
_ => (),
}
}
@@ -762,10 +762,10 @@ impl NodeTrait for TSpan {
fn set_atts(&mut self, _: Option<&RsvgNode>, pbag: &PropertyBag<'_>) -> NodeResult {
for (attr, value) in pbag.iter() {
match attr.expanded() {
- expanded_name!(svg "x") => self.x = attr.parse_to_parse_error(value).map(Some)?,
- expanded_name!(svg "y") => self.y = attr.parse_to_parse_error(value).map(Some)?,
- expanded_name!(svg "dx") => self.dx = attr.parse_to_parse_error(value).map(Some)?,
- expanded_name!(svg "dy") => self.dy = attr.parse_to_parse_error(value).map(Some)?,
+ expanded_name!(svg "x") => self.x = attr.parse(value).map(Some)?,
+ expanded_name!(svg "y") => self.y = attr.parse(value).map(Some)?,
+ expanded_name!(svg "dx") => self.dx = attr.parse(value).map(Some)?,
+ expanded_name!(svg "dy") => self.dy = attr.parse(value).map(Some)?,
_ => (),
}
}
diff --git a/rsvg_internals/src/transform.rs b/rsvg_internals/src/transform.rs
index 5abd9a03..e623adb4 100644
--- a/rsvg_internals/src/transform.rs
+++ b/rsvg_internals/src/transform.rs
@@ -7,12 +7,10 @@ use std::f64::consts::*;
use cssparser::{self, Parser, Token};
use crate::error::*;
-use crate::parsers::{optional_comma, ParseToParseError};
+use crate::parsers::{optional_comma, Parse};
-impl ParseToParseError for cairo::Matrix {
- fn parse_to_parse_error<'i>(
- parser: &mut Parser<'i, '_>,
- ) -> Result<cairo::Matrix, CssParseError<'i>> {
+impl Parse for cairo::Matrix {
+ fn parse<'i>(parser: &mut Parser<'i, '_>) -> Result<cairo::Matrix, CssParseError<'i>> {
let loc = parser.current_source_location();
let matrix = parse_transform_list(parser)?;
@@ -86,22 +84,22 @@ fn parse_transform_function<'i>(
fn parse_matrix_args<'i>(parser: &mut Parser<'i, '_>) -> Result<cairo::Matrix, CssParseError<'i>> {
parser.parse_nested_block(|p| {
- let xx = f64::parse_to_parse_error(p)?;
+ let xx = f64::parse(p)?;
optional_comma(p);
- let yx = f64::parse_to_parse_error(p)?;
+ let yx = f64::parse(p)?;
optional_comma(p);
- let xy = f64::parse_to_parse_error(p)?;
+ let xy = f64::parse(p)?;
optional_comma(p);
- let yy = f64::parse_to_parse_error(p)?;
+ let yy = f64::parse(p)?;
optional_comma(p);
- let x0 = f64::parse_to_parse_error(p)?;
+ let x0 = f64::parse(p)?;
optional_comma(p);
- let y0 = f64::parse_to_parse_error(p)?;
+ let y0 = f64::parse(p)?;
Ok(cairo::Matrix::new(xx, yx, xy, yy, x0, y0))
})
@@ -111,12 +109,12 @@ fn parse_translate_args<'i>(
parser: &mut Parser<'i, '_>,
) -> Result<cairo::Matrix, CssParseError<'i>> {
parser.parse_nested_block(|p| {
- let tx = f64::parse_to_parse_error(p)?;
+ let tx = f64::parse(p)?;
let ty = p
.try_parse(|p| {
optional_comma(p);
- f64::parse_to_parse_error(p)
+ f64::parse(p)
})
.unwrap_or(0.0);
@@ -126,12 +124,12 @@ fn parse_translate_args<'i>(
fn parse_scale_args<'i>(parser: &mut Parser<'i, '_>) -> Result<cairo::Matrix, CssParseError<'i>> {
parser.parse_nested_block(|p| {
- let x = f64::parse_to_parse_error(p)?;
+ let x = f64::parse(p)?;
let y = p
.try_parse(|p| {
optional_comma(p);
- f64::parse_to_parse_error(p)
+ f64::parse(p)
})
.unwrap_or(x);
@@ -141,15 +139,15 @@ fn parse_scale_args<'i>(parser: &mut Parser<'i, '_>) -> Result<cairo::Matrix, Cs
fn parse_rotate_args<'i>(parser: &mut Parser<'i, '_>) -> Result<cairo::Matrix, CssParseError<'i>> {
parser.parse_nested_block(|p| {
- let angle = f64::parse_to_parse_error(p)? * PI / 180.0;
+ let angle = f64::parse(p)? * PI / 180.0;
let (tx, ty) = p
.try_parse(|p| -> Result<_, CssParseError> {
optional_comma(p);
- let tx = f64::parse_to_parse_error(p)?;
+ let tx = f64::parse(p)?;
optional_comma(p);
- let ty = f64::parse_to_parse_error(p)?;
+ let ty = f64::parse(p)?;
Ok((tx, ty))
})
@@ -167,14 +165,14 @@ fn parse_rotate_args<'i>(parser: &mut Parser<'i, '_>) -> Result<cairo::Matrix, C
fn parse_skewx_args<'i>(parser: &mut Parser<'i, '_>) -> Result<cairo::Matrix, CssParseError<'i>> {
parser.parse_nested_block(|p| {
- let a = f64::parse_to_parse_error(p)? * PI / 180.0;
+ let a = f64::parse(p)? * PI / 180.0;
Ok(cairo::Matrix::new(1.0, 0.0, a.tan(), 1.0, 0.0, 0.0))
})
}
fn parse_skewy_args<'i>(parser: &mut Parser<'i, '_>) -> Result<cairo::Matrix, CssParseError<'i>> {
parser.parse_nested_block(|p| {
- let a = f64::parse_to_parse_error(p)? * PI / 180.0;
+ let a = f64::parse(p)? * PI / 180.0;
Ok(cairo::Matrix::new(1.0, a.tan(), 0.0, 1.0, 0.0, 0.0))
})
}
@@ -200,7 +198,7 @@ mod tests {
use std::f64;
fn parse_transform(s: &str) -> Result<cairo::Matrix, CssParseError> {
- cairo::Matrix::parse_str_to_parse_error(s)
+ cairo::Matrix::parse_str(s)
}
fn assert_matrix_eq(a: &cairo::Matrix, b: &cairo::Matrix) {
diff --git a/rsvg_internals/src/unit_interval.rs b/rsvg_internals/src/unit_interval.rs
index 34575692..2aad1c3f 100644
--- a/rsvg_internals/src/unit_interval.rs
+++ b/rsvg_internals/src/unit_interval.rs
@@ -3,7 +3,7 @@
use cssparser::Parser;
use crate::error::*;
-use crate::parsers::ParseToParseError;
+use crate::parsers::Parse;
use crate::util;
#[derive(Debug, Default, Copy, Clone, PartialEq, PartialOrd)]
@@ -15,9 +15,9 @@ impl UnitInterval {
}
}
-impl ParseToParseError for UnitInterval {
- fn parse_to_parse_error<'i>(parser: &mut Parser<'i, '_>) -> Result<UnitInterval, CssParseError<'i>> {
- let x = f64::parse_to_parse_error(parser)?;
+impl Parse for UnitInterval {
+ fn parse<'i>(parser: &mut Parser<'i, '_>) -> Result<UnitInterval, CssParseError<'i>> {
+ let x = f64::parse(parser)?;
Ok(UnitInterval::clamp(x))
}
}
@@ -44,23 +44,23 @@ mod tests {
#[test]
fn parses_number() {
- assert_eq!(UnitInterval::parse_str_to_parse_error("0"), Ok(UnitInterval(0.0)));
- assert_eq!(UnitInterval::parse_str_to_parse_error("1"), Ok(UnitInterval(1.0)));
- assert_eq!(UnitInterval::parse_str_to_parse_error("0.5"), Ok(UnitInterval(0.5)));
+ assert_eq!(UnitInterval::parse_str("0"), Ok(UnitInterval(0.0)));
+ assert_eq!(UnitInterval::parse_str("1"), Ok(UnitInterval(1.0)));
+ assert_eq!(UnitInterval::parse_str("0.5"), Ok(UnitInterval(0.5)));
}
#[test]
fn parses_out_of_range_number() {
- assert_eq!(UnitInterval::parse_str_to_parse_error("-10"), Ok(UnitInterval(0.0)));
- assert_eq!(UnitInterval::parse_str_to_parse_error("10"), Ok(UnitInterval(1.0)));
+ assert_eq!(UnitInterval::parse_str("-10"), Ok(UnitInterval(0.0)));
+ assert_eq!(UnitInterval::parse_str("10"), Ok(UnitInterval(1.0)));
}
#[test]
fn errors_on_invalid_input() {
- assert!(UnitInterval::parse_str_to_parse_error("").is_err());
- assert!(UnitInterval::parse_str_to_parse_error("foo").is_err());
- assert!(UnitInterval::parse_str_to_parse_error("-x").is_err());
- assert!(UnitInterval::parse_str_to_parse_error("0.0foo").is_err());
+ assert!(UnitInterval::parse_str("").is_err());
+ assert!(UnitInterval::parse_str("foo").is_err());
+ assert!(UnitInterval::parse_str("-x").is_err());
+ assert!(UnitInterval::parse_str("0.0foo").is_err());
}
#[test]
diff --git a/rsvg_internals/src/viewbox.rs b/rsvg_internals/src/viewbox.rs
index 360466d9..9a6fa247 100644
--- a/rsvg_internals/src/viewbox.rs
+++ b/rsvg_internals/src/viewbox.rs
@@ -4,13 +4,13 @@ use cssparser::Parser;
use crate::error::*;
use crate::number_list::{NumberList, NumberListLength};
-use crate::parsers::ParseToParseError;
+use crate::parsers::Parse;
use crate::rect::Rect;
#[derive(Debug, Copy, Clone, PartialEq)]
pub struct ViewBox(pub Rect);
-impl ParseToParseError for ViewBox {
+impl Parse for ViewBox {
// Parse a viewBox attribute
// https://www.w3.org/TR/SVG/coords.html#ViewBoxAttribute
//
@@ -19,18 +19,19 @@ impl ParseToParseError for ViewBox {
// x, y, w, h
//
// Where w and h must be nonnegative.
- fn parse_to_parse_error<'i>(parser: &mut Parser<'i, '_>) -> Result<ViewBox, CssParseError<'i>> {
+ fn parse<'i>(parser: &mut Parser<'i, '_>) -> Result<ViewBox, CssParseError<'i>> {
let loc = parser.current_source_location();
- let NumberList(v) =
- NumberList::parse_to_parse_error(parser, NumberListLength::Exact(4))?;
+ let NumberList(v) = NumberList::parse(parser, NumberListLength::Exact(4))?;
let (x, y, width, height) = (v[0], v[1], v[2], v[3]);
if width >= 0.0 && height >= 0.0 {
Ok(ViewBox(Rect::new(x, y, x + width, y + height)))
} else {
- Err(loc.new_custom_error(ValueErrorKind::value_error("width and height must not be negative")))
+ Err(loc.new_custom_error(ValueErrorKind::value_error(
+ "width and height must not be negative",
+ )))
}
}
}
@@ -42,25 +43,25 @@ mod tests {
#[test]
fn parses_valid_viewboxes() {
assert_eq!(
- ViewBox::parse_str_to_parse_error(" 1 2 3 4"),
+ ViewBox::parse_str(" 1 2 3 4"),
Ok(ViewBox(Rect::new(1.0, 2.0, 4.0, 6.0)))
);
assert_eq!(
- ViewBox::parse_str_to_parse_error(" -1.5 -2.5e1,34,56e2 "),
+ ViewBox::parse_str(" -1.5 -2.5e1,34,56e2 "),
Ok(ViewBox(Rect::new(-1.5, -25.0, 32.5, 5575.0)))
);
}
#[test]
fn parsing_invalid_viewboxes_yields_error() {
- assert!(ViewBox::parse_str_to_parse_error("").is_err());
- assert!(ViewBox::parse_str_to_parse_error(" 1,2,-3,-4 ").is_err());
- assert!(ViewBox::parse_str_to_parse_error("qwerasdfzxcv").is_err());
- assert!(ViewBox::parse_str_to_parse_error(" 1 2 3 4 5").is_err());
- assert!(ViewBox::parse_str_to_parse_error(" 1 2 foo 3 4").is_err());
+ assert!(ViewBox::parse_str("").is_err());
+ assert!(ViewBox::parse_str(" 1,2,-3,-4 ").is_err());
+ assert!(ViewBox::parse_str("qwerasdfzxcv").is_err());
+ assert!(ViewBox::parse_str(" 1 2 3 4 5").is_err());
+ assert!(ViewBox::parse_str(" 1 2 foo 3 4").is_err());
// https://gitlab.gnome.org/GNOME/librsvg/issues/344
- assert!(ViewBox::parse_str_to_parse_error("0 0 9E80.7").is_err());
+ assert!(ViewBox::parse_str("0 0 9E80.7").is_err());
}
}
diff --git a/rsvg_internals/src/xml.rs b/rsvg_internals/src/xml.rs
index 49cbf7df..c73a47db 100644
--- a/rsvg_internals/src/xml.rs
+++ b/rsvg_internals/src/xml.rs
@@ -4,7 +4,16 @@ use crate::xml_rs::{reader::XmlEvent, ParserConfig};
use encoding::label::encoding_from_whatwg_label;
use encoding::DecoderTrap;
use libc;
-use markup5ever::{expanded_name, local_name, namespace_url, ns, ExpandedName, LocalName, Namespace,
QualName};
+use markup5ever::{
+ expanded_name,
+ local_name,
+ namespace_url,
+ ns,
+ ExpandedName,
+ LocalName,
+ Namespace,
+ QualName,
+};
use std::cell::RefCell;
use std::collections::HashMap;
use std::rc::{Rc, Weak};
@@ -271,7 +280,10 @@ impl XmlState {
.append_stylesheet_from_xml_processing_instruction(alternate, type_, &href)
.is_err()
{
- rsvg_log!("invalid xml-stylesheet {} in XML processing instruction", href);
+ rsvg_log!(
+ "invalid xml-stylesheet {} in XML processing instruction",
+ href
+ );
}
} else {
rsvg_log!("xml-stylesheet processing instruction does not have href; ignoring");
@@ -363,7 +375,8 @@ impl XmlState {
.unwrap_or(StyleType::TextCss);
if style_type == StyleType::TextCss {
- let stylesheet_text = current_node.children()
+ let stylesheet_text = current_node
+ .children()
.map(|child| {
let child_borrow = child.borrow();
[
Date Prev][
Date Next] [
Thread Prev][
Thread Next]
[
Thread Index]
[
Date Index]
[
Author Index]
