Bump to resvg 0.40 (#62)

Author: LaurenzV

Cargo.lock

@@ -16,17 +16,17 @@ svg2pdf = { path = ".", version = "0.9.1" }
 clap = { version = "4.4.2", features = ["derive"] }
 clap_complete = "4.4.3"
 clap_mangen = "0.2.14"
-fontdb = "0.16.0"
+fontdb = "0.16.1"
 image = { version = "0.24", default-features = false, features = ["jpeg", "png", "gif"] }
 miniz_oxide = "0.7"
 once_cell = "1.18.0"
 oxipng = { version = "9", default-features = false, features = ["filetime", "parallel", "zopfli"] }
 pdf-writer = "0.9"
 pdfium-render = "0.8.6"
 termcolor = "1.2"
-usvg = { version = "0.38.0", default-features = false, features = ["text"] }
-tiny-skia = "0.11.3"
-resvg = { version = "0.38.0" }
+usvg = { version = "0.40", default-features = false, features = ["text"] }
+tiny-skia = "0.11.4"
+resvg = "0.40"
 
 [package]
 name = "svg2pdf"

Cargo.toml

@@ -10,24 +10,9 @@ This crate allows to convert static (i.e. non-interactive) SVG files to
 either standalone PDF files or Form XObjects that can be embedded in another
 PDF file and used just like images.
 
-Apart from groups with filters on them, the conversion will translate 
-the SVG content to PDF without rasterizing it, so no quality is lost.
-
-## Example
-
-This example reads an SVG file and writes the corresponding PDF back to the disk.
-
-```rust
-let path = "tests/svg/custom/integration/matplotlib/time_series.svg";
-let svg = std::fs::read_to_string(path)?;
-
-// This can only fail if the SVG is malformed. This one is not.
-let pdf = svg2pdf::convert_str(&svg, svg2pdf::Options::default())?;
-
-// ... and now you have a Vec<u8> which you could write to a file or
-// transmit over the network!
-std::fs::write("target/time_series.pdf", pdf)?;
-```
+See the [documentation](https://docs.rs/svg2pdf/latest/svg2pdf/) for a more detailed
+description, including which features are supported and which are not, as well as for
+examples on how to use this library.
 
 ## CLI
 
@@ -44,28 +29,6 @@ You can then convert SVGs to PDFs by running commands like these:
 svg2pdf your.svg
 ```
 
-## Supported features
-In general, a large part of the SVG specification is supported, including
-features like:
-- Path drawing with fills and strokes
-- Gradients
-- Patterns
-- Clip paths
-- Masks
-- Filters
-- Transformation matrices
-- Respecting the `keepAspectRatio` attribute
-- Raster images and nested SVGs
-
-## Unsupported features
-Among the unsupported features are currently:
-- The `spreadMethod` attribute of gradients
-- Text will be converted into shapes before converting to PDF. It is planned
-to add support for text preservation in a future update.
-- Raster images are not color managed but use PDF's DeviceRGB color space
-- A number of features that were added in SVG2 
-(see [here](https://github.com/RazrFalcon/resvg/blob/master/docs/svg2-changelog.md))
-
 ## Contributing
 We are looking forward to receiving your bugs and feature requests in the Issues
 tab. We would also be very happy to accept PRs for bug fixes, features, or

README.md

@@ -1,7 +1,6 @@
 use crate::args::ConvertCommand;
 use std::path::{Path, PathBuf};
 use svg2pdf::Options;
-use usvg::{PostProcessingSteps, TreeParsing, TreePostProc};
 
 /// Execute a font listing command.
 pub fn _convert(command: ConvertCommand) -> Result<(), String> {
@@ -31,8 +30,8 @@ pub fn convert_(
 
     let options = usvg::Options::default();
 
-    let mut tree = usvg::Tree::from_str(&svg, &options).map_err(|err| err.to_string())?;
-    tree.postprocess(PostProcessingSteps::default(), &fontdb);
+    let tree =
+        usvg::Tree::from_str(&svg, &options, &fontdb).map_err(|err| err.to_string())?;
 
     let pdf = svg2pdf::convert_tree(&tree, Options { dpi, ..Options::default() });
 

cli/src/convert.rs

@@ -4,19 +4,25 @@ This crate allows to convert static (i.e. non-interactive) SVG files to
 either standalone PDF files or Form XObjects that can be embedded in another
 PDF file and used just like images.
 
-The conversion will translate the SVG content to PDF without rasterizing them,
-so no quality is lost.
+The conversion will translate the SVG content to PDF without rasterizing them
+(the only exception being objects with filters on them, but in this case only
+this single group will be rasterized, while the remaining contents of the SVG
+will still be turned into a vector graphic), so no quality is lost.
 
 ## Example
 This example reads an SVG file and writes the corresponding PDF back to the disk.
 
 ```
 # fn main() -> Result<(), Box<dyn std::error::Error>> {
+use svg2pdf::usvg::fontdb;
+
 let path = "tests/svg/custom/integration/matplotlib/time_series.svg";
 let svg = std::fs::read_to_string(path)?;
+let mut db = fontdb::Database::new();
+db.load_system_fonts();
 
 // This can only fail if the SVG is malformed. This one is not.
-let pdf = svg2pdf::convert_str(&svg, svg2pdf::Options::default())?;
+let pdf = svg2pdf::convert_str(&svg, svg2pdf::Options::default(), &db)?;
 
 // ... and now you have a Vec<u8> which you could write to a file or
 // transmit over the network!
@@ -25,22 +31,26 @@ std::fs::write("target/time_series.pdf", pdf)?;
 ```
 
 ## Supported features
-In general, a large part of the SVG specification is supported, including features like:
-- Path drawing with fills and strokes
+In general, a very large part of the SVG specification is supported, including
+but not limited to:
+- Paths with simple and complex fills
 - Gradients
 - Patterns
 - Clip paths
 - Masks
-- Transformation matrices
-- Respecting the `keepAspectRatio` attribute
+- Transformations
+- Viewbox
+- Text (although it will be converted into paths)
 - Raster images and nested SVGs
 
 ## Unsupported features
 Among the unsupported features are currently:
 - The `spreadMethod` attribute of gradients
 - Filters
 - Raster images are not color managed but use PDF's DeviceRGB color space
-- A number of features that were added in SVG2
+- A number of features that were added in SVG2, See
+[here](https://github.com/RazrFalcon/resvg/blob/master/docs/svg2-changelog.md) for a more
+comprehensive list.
  */
 
 mod render;
@@ -50,8 +60,7 @@ pub use usvg;
 
 use once_cell::sync::Lazy;
 use pdf_writer::{Chunk, Content, Filter, Finish, Pdf, Rect, Ref, TextStr};
-use usvg::utils::view_box_to_transform;
-use usvg::{Align, AspectRatio, NonZeroRect, Size, Transform, Tree, TreeParsing};
+use usvg::{fontdb, Align, AspectRatio, NonZeroRect, Size, Transform, Tree, ViewBox};
 
 use crate::render::tree_to_stream;
 use crate::util::context::Context;
@@ -134,19 +143,17 @@ impl Default for Options {
 
 /// Convert an SVG source string to a standalone PDF buffer.
 ///
-/// Does not load any fonts and consequently cannot convert `text` elements. To
-/// convert text, you should convert your source string to a
-/// [`usvg` tree](Tree) manually,
-/// [convert text with usvg](usvg::TreePostProc::postprocess) and then use
-/// [`convert_tree`].
-///
 /// Returns an error if the SVG string is malformed.
-pub fn convert_str(src: &str, options: Options) -> Result<Vec<u8>, usvg::Error> {
+pub fn convert_str(
+    src: &str,
+    options: Options,
+    fontdb: &fontdb::Database,
+) -> Result<Vec<u8>, usvg::Error> {
     let mut usvg_options = usvg::Options::default();
     if let Some(size) = options.viewport {
         usvg_options.default_size = size;
     }
-    let tree = Tree::from_str(src, &usvg_options)?;
+    let tree = Tree::from_str(src, &usvg_options, fontdb)?;
     Ok(convert_tree(&tree, options))
 }
 
@@ -158,19 +165,17 @@ pub fn convert_str(src: &str, options: Options) -> Result<Vec<u8>, usvg::Error>
 ///
 /// ```
 /// # fn main() -> Result<(), Box<dyn std::error::Error>> {
-/// use svg2pdf::usvg::{fontdb, PostProcessingSteps, TreeParsing, TreePostProc};
+/// use svg2pdf::usvg::fontdb;
 /// use svg2pdf::Options;
 ///
 /// let input = "tests/svg/custom/integration/matplotlib/step.svg";
 /// let output = "target/step.pdf";
 ///
 /// let svg = std::fs::read_to_string(input)?;
 /// let options = svg2pdf::usvg::Options::default();
-/// let mut tree = svg2pdf::usvg::Tree::from_str(&svg, &options)?;
-///
 /// let mut db = fontdb::Database::new();
 /// db.load_system_fonts();
-/// tree.postprocess(PostProcessingSteps::default(), &db);
+/// let mut tree = svg2pdf::usvg::Tree::from_str(&svg, &options, &db)?;
 ///
 ///
 /// let pdf = svg2pdf::convert_tree(&tree, Options::default());
@@ -256,7 +261,7 @@ pub fn convert_tree(tree: &Tree, options: Options) -> Vec<u8> {
 /// # fn main() -> Result<(), Box<dyn std::error::Error>> {
 /// use svg2pdf;
 /// use pdf_writer::{Content, Finish, Name, Pdf, Rect, Ref, Str};
-/// use svg2pdf::usvg::TreeParsing;
+/// use svg2pdf::usvg::fontdb;
 ///
 /// // Allocate the indirect reference IDs and names.
 /// let catalog_id = Ref::new(1);
@@ -294,7 +299,9 @@ pub fn convert_tree(tree: &Tree, options: Options) -> Vec<u8> {
 /// // We need to load its source first and manually parse it into a usvg Tree.
 /// let path = "tests/svg/custom/integration/matplotlib/step.svg";
 /// let svg = std::fs::read_to_string(path)?;
-/// let tree = svg2pdf::usvg::Tree::from_str(&svg, &svg2pdf::usvg::Options::default())?;
+/// let mut db = fontdb::Database::new();
+/// db.load_system_fonts();
+/// let tree = svg2pdf::usvg::Tree::from_str(&svg, &svg2pdf::usvg::Options::default(), &db)?;
 ///
 /// // Then, we will write it to the page as the 6th indirect object.
 /// //
@@ -391,7 +398,7 @@ fn write_color_spaces(ctx: &mut Context, chunk: &mut Chunk) {
 /// Return the dimensions of the PDF page
 fn pdf_size(tree: &Tree, options: Options) -> Size {
     // If no custom viewport is defined, we use the size of the tree.
-    let viewport_size = options.viewport.unwrap_or(tree.size);
+    let viewport_size = options.viewport.unwrap_or(tree.size());
     Size::from_wh(
         // dpi_ratio is in dot per user unit so dividing by it gave user unit
         viewport_size.width() / dpi_ratio(options.dpi),
@@ -410,11 +417,16 @@ fn initial_transform(
     // Account for the custom viewport that has been passed in the Options struct. If nothing has
     // been passed, pdf_size should be the same as tree.size, so the transform will just be the
     // default transform.
-    let custom_viewport_transform = view_box_to_transform(
-        NonZeroRect::from_xywh(0.0, 0.0, tree.size.width(), tree.size.height()).unwrap(),
-        aspect.unwrap_or(AspectRatio { defer: false, align: Align::None, slice: false }),
-        pdf_size,
-    );
+    let view_box = ViewBox {
+        rect: NonZeroRect::from_xywh(0.0, 0.0, tree.size().width(), tree.size().height())
+            .unwrap(),
+        aspect: aspect.unwrap_or(AspectRatio {
+            defer: false,
+            align: Align::None,
+            slice: false,
+        }),
+    };
+    let custom_viewport_transform = view_box.to_transform(pdf_size);
 
     // Account for the direction of the y axis and the shift of the origin in the coordinate system.
     let pdf_transform = Transform::from_row(1.0, 0.0, 0.0, -1.0, 0.0, pdf_size.height());