feat: Non-blocking stylesheet resolving

Stranger6667 · Stranger6667 · commit bf4921302d2e · 2024-01-01T18:40:13.000+01:00
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -5,6 +5,7 @@
 ### Added
 
 - A way to customize resolving remote stylesheets.
+- Non-blocking stylesheet resolving by default.
 
 ### Changed
 
diff --git a/README.md b/README.md
@@ -70,8 +70,21 @@ const HTML: &str = r#"<html>
 </body>
 </html>"#;
 
+#[tokio::main]
+async fn main() -> css_inline::Result<()> {
+    let inlined = css_inline::inline(HTML).await?;
+    // Do something with inlined HTML, e.g. send an email
+    Ok(())
+}
+```
+
+There is also a "blocking" API for inlining:
+
+```rust
+const HTML: &str = "...";
+
 fn main() -> css_inline::Result<()> {
-    let inlined = css_inline::inline(HTML)?;
+    let inlined = css_inline::blocking::inline(HTML)?;
     // Do something with inlined HTML, e.g. send an email
     Ok(())
 }
@@ -84,11 +97,12 @@ fn main() -> css_inline::Result<()> {
 ```rust
 const HTML: &str = "...";
 
-fn main() -> css_inline::Result<()> {
+#[tokio::main]
+async fn main() -> css_inline::Result<()> {
     let inliner = css_inline::CSSInliner::options()
         .load_remote_stylesheets(false)
         .build();
-    let inlined = inliner.inline(HTML)?;
+    let inlined = inliner.inline(HTML).await?;
     // Do something with inlined HTML, e.g. send an email
     Ok(())
 }
@@ -131,12 +145,28 @@ If you'd like to load stylesheets from your filesystem, use the `file://` scheme
 ```rust
 const HTML: &str = "...";
 
-fn main() -> css_inline::Result<()> {
+#[tokio::main]
+async fn main() -> css_inline::Result<()> {
     let base_url = css_inline::Url::parse("file://styles/email/").expect("Invalid URL");
     let inliner = css_inline::CSSInliner::options()
         .base_url(Some(base_url))
         .build();
-    let inlined = inliner.inline(HTML);
+    let inlined = inliner.inline(HTML).await?;
+    // Do something with inlined HTML, e.g. send an email
+    Ok(())
+}
+```
+
+The blocking version is available as well:
+
+```rust
+const HTML: &str = "...";
+
+fn main() -> css_inline::Result<()> {
+    let inliner = css_inline::blocking::CSSInliner::options()
+        .load_remote_stylesheets(false)
+        .build();
+    let inlined = inliner.inline(HTML)?;
     // Do something with inlined HTML, e.g. send an email
     Ok(())
 }
@@ -149,7 +179,7 @@ For resolving remote stylesheets it is possible to implement a custom resolver:
 pub struct CustomStylesheetResolver;
 
 impl css_inline::StylesheetResolver for CustomStylesheetResolver {
-    fn retrieve(&self, location: &str) -> css_inline::Result<String> {
+    fn retrieve_blocking(&self, location: &str) -> css_inline::Result<String> {
         Err(self.unsupported("External stylesheets are not supported"))
     }
 }
diff --git a/bindings/c/Cargo.toml b/bindings/c/Cargo.toml
@@ -18,4 +18,4 @@ cbindgen = "0.26"
 path = "../../css-inline"
 version = "*"
 default-features = false
-features = ["http", "file"]
+features = ["http-blocking", "file"]
diff --git a/bindings/c/src/lib.rs b/bindings/c/src/lib.rs
@@ -1,4 +1,7 @@
-use css_inline::{CSSInliner, DefaultStylesheetResolver, InlineError, InlineOptions, Url};
+use css_inline::{
+    blocking::{CSSInliner, InlineOptions},
+    DefaultStylesheetResolver, InlineError, Url,
+};
 use libc::{c_char, size_t};
 use std::{borrow::Cow, cmp, ffi::CStr, io::Write, ptr, sync::Arc};
 
diff --git a/bindings/javascript/Cargo.toml b/bindings/javascript/Cargo.toml
@@ -32,7 +32,7 @@ serde = { version = "1", features = ["derive"], default-features = false }
 path = "../../css-inline"
 version = "*"
 default-features = false
-features = ["http", "file"]
+features = ["http-blocking", "file"]
 
 [target.'cfg(target_arch = "wasm32")'.dependencies.css-inline]
 path = "../../css-inline"
diff --git a/bindings/javascript/src/lib.rs b/bindings/javascript/src/lib.rs
@@ -60,6 +60,6 @@ export function inline(html: string, options?: InlineOptions): string;
 export function version(): string;"#;
 
 fn inline_inner(html: String, options: Options) -> std::result::Result<String, errors::JsError> {
-    let inliner = css_inline::CSSInliner::new(options.try_into()?);
+    let inliner = css_inline::blocking::CSSInliner::new(options.try_into()?);
     Ok(inliner.inline(&html).map_err(errors::InlineError)?)
 }
diff --git a/bindings/javascript/src/options.rs b/bindings/javascript/src/options.rs
@@ -42,11 +42,11 @@ pub struct Options {
     pub preallocate_node_capacity: Option<u32>,
 }
 
-impl TryFrom<Options> for css_inline::InlineOptions<'_> {
+impl TryFrom<Options> for css_inline::blocking::InlineOptions<'_> {
     type Error = JsError;
 
     fn try_from(value: Options) -> std::result::Result<Self, Self::Error> {
-        Ok(css_inline::InlineOptions {
+        Ok(css_inline::blocking::InlineOptions {
             inline_style_tags: value.inline_style_tags.unwrap_or(true),
             keep_style_tags: value.keep_style_tags.unwrap_or(false),
             keep_link_tags: value.keep_link_tags.unwrap_or(false),
diff --git a/bindings/python/Cargo.toml b/bindings/python/Cargo.toml
@@ -23,7 +23,7 @@ url = "2"
 path = "../../css-inline"
 version = "*"
 default-features = false
-features = ["http", "file"]
+features = ["http-blocking", "file"]
 
 [profile.release]
 codegen-units = 1
diff --git a/bindings/python/src/lib.rs b/bindings/python/src/lib.rs
@@ -74,12 +74,12 @@ fn parse_url(url: Option<String>) -> PyResult<Option<rust_inline::Url>> {
 /// Customizable CSS inliner.
 #[pyclass]
 struct CSSInliner {
-    inner: rust_inline::CSSInliner<'static>,
+    inner: rust_inline::blocking::CSSInliner<'static>,
 }
 
 macro_rules! inliner {
     ($inline_style_tags:expr, $keep_style_tags:expr, $keep_link_tags:expr, $base_url:expr, $load_remote_stylesheets:expr, $extra_css:expr, $preallocate_node_capacity:expr) => {{
-        let options = rust_inline::InlineOptions {
+        rust_inline::blocking::InlineOptions {
             inline_style_tags: $inline_style_tags.unwrap_or(true),
             keep_style_tags: $keep_style_tags.unwrap_or(false),
             keep_link_tags: $keep_link_tags.unwrap_or(false),
@@ -88,8 +88,8 @@ macro_rules! inliner {
             extra_css: $extra_css.map(Into::into),
             preallocate_node_capacity: $preallocate_node_capacity.unwrap_or(32),
             resolver: std::sync::Arc::new(rust_inline::DefaultStylesheetResolver),
-        };
-        rust_inline::CSSInliner::new(options)
+        }
+        .build()
     }};
 }
 
@@ -198,7 +198,7 @@ fn inline_many(
 }
 
 fn inline_many_impl(
-    inliner: &rust_inline::CSSInliner<'_>,
+    inliner: &rust_inline::blocking::CSSInliner<'_>,
     htmls: &PyList,
 ) -> PyResult<Vec<String>> {
     // Extract strings from the list. It will fail if there is any non-string value
diff --git a/bindings/ruby/ext/css_inline/Cargo.toml b/bindings/ruby/ext/css_inline/Cargo.toml
@@ -23,4 +23,4 @@ rayon = "1"
 path = "../../../../css-inline"
 version = "*"
 default-features = false
-features = ["http", "file"]
+features = ["http-blocking", "file"]
diff --git a/bindings/ruby/ext/css_inline/src/lib.rs b/bindings/ruby/ext/css_inline/src/lib.rs
@@ -39,7 +39,7 @@ type RubyResult<T> = Result<T, magnus::Error>;
 
 fn parse_options<Req>(
     args: &Args<Req, (), (), (), RHash, ()>,
-) -> RubyResult<rust_inline::InlineOptions<'static>> {
+) -> RubyResult<rust_inline::blocking::InlineOptions<'static>> {
     let kwargs = get_kwargs::<
         _,
         (),
@@ -67,7 +67,7 @@ fn parse_options<Req>(
         ],
     )?;
     let kwargs = kwargs.optional;
-    Ok(rust_inline::InlineOptions {
+    Ok(rust_inline::blocking::InlineOptions {
         inline_style_tags: kwargs.0.unwrap_or(true),
         keep_style_tags: kwargs.1.unwrap_or(false),
         keep_link_tags: kwargs.2.unwrap_or(false),
@@ -81,7 +81,7 @@ fn parse_options<Req>(
 
 #[magnus::wrap(class = "CSSInline::CSSInliner")]
 struct CSSInliner {
-    inner: rust_inline::CSSInliner<'static>,
+    inner: rust_inline::blocking::CSSInliner<'static>,
 }
 
 struct InlineErrorWrapper(rust_inline::InlineError);
@@ -133,7 +133,7 @@ impl CSSInliner {
         let args = scan_args::<(), _, _, _, _, _>(args)?;
         let options = parse_options(&args)?;
         Ok(CSSInliner {
-            inner: rust_inline::CSSInliner::new(options),
+            inner: rust_inline::blocking::CSSInliner::new(options),
         })
     }
 
@@ -152,21 +152,21 @@ fn inline(args: &[Value]) -> RubyResult<String> {
     let args = scan_args::<(String,), _, _, _, _, _>(args)?;
     let options = parse_options(&args)?;
     let html = args.required.0;
-    Ok(rust_inline::CSSInliner::new(options)
+    Ok(rust_inline::blocking::CSSInliner::new(options)
         .inline(&html)
         .map_err(InlineErrorWrapper)?)
 }
 
 fn inline_many(args: &[Value]) -> RubyResult<Vec<String>> {
     let args = scan_args::<(Vec<String>,), _, _, _, _, _>(args)?;
     let options = parse_options(&args)?;
-    let inliner = rust_inline::CSSInliner::new(options);
+    let inliner = rust_inline::blocking::CSSInliner::new(options);
     inline_many_impl(&args.required.0, &inliner)
 }
 
 fn inline_many_impl(
     htmls: &[String],
-    inliner: &rust_inline::CSSInliner<'static>,
+    inliner: &rust_inline::blocking::CSSInliner<'static>,
 ) -> RubyResult<Vec<String>> {
     let output: Result<Vec<_>, _> = htmls.par_iter().map(|html| inliner.inline(html)).collect();
     Ok(output.map_err(InlineErrorWrapper)?)
diff --git a/css-inline/Cargo.toml b/css-inline/Cargo.toml
@@ -22,18 +22,20 @@ rust-version = "1.65"
 name = "css-inline"
 
 [features]
-default = ["cli", "http", "file"]
+default = ["cli", "http", "http-blocking", "file"]
 cli = ["pico-args", "rayon"]
 http = ["reqwest"]
+http-blocking = ["reqwest/blocking"]
 file = []
 
 [dependencies]
 cssparser = "0.31.2"
+futures-util = "0.3.30"
 html5ever = "0.26.0"
 indexmap = "2.1"
 pico-args = { version = "0.3", optional = true }
 rayon = { version = "1.7", optional = true }
-reqwest = { version = "0.11.23", optional = true, default-features = false, features = ["rustls-tls", "blocking"] }
+reqwest = { version = "0.11.23", optional = true, default-features = false, features = ["rustls-tls"] }
 rustc-hash = "1.1.0"
 selectors = "0.25.0"
 smallvec = "1"
@@ -46,6 +48,7 @@ criterion = { version = "0.5.1", features = [], default-features = false }
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"
 test-case = "3.3"
+tokio = { version = "1.32", features = ["macros", "rt"] }
 
 [[bench]]
 name = "inliner"
diff --git a/css-inline/benches/inliner.rs b/css-inline/benches/inliner.rs
@@ -1,5 +1,5 @@
 use codspeed_criterion_compat::{black_box, criterion_group, criterion_main, Criterion};
-use css_inline::inline_to;
+use css_inline::blocking::inline_to;
 use std::fs;
 
 #[derive(serde::Deserialize, Debug)]
diff --git a/css-inline/src/error.rs b/css-inline/src/error.rs
@@ -20,7 +20,7 @@ pub enum InlineError {
     /// from the filesystem.
     IO(io::Error),
     /// Network-related problem. E.g. resource is not available.
-    #[cfg(feature = "http")]
+    #[cfg(any(feature = "http", feature = "http-blocking"))]
     Network {
         /// Original network error.
         error: reqwest::Error,
@@ -41,7 +41,7 @@ impl Error for InlineError {
     fn source(&self) -> Option<&(dyn Error + 'static)> {
         match self {
             InlineError::IO(error) => Some(error),
-            #[cfg(feature = "http")]
+            #[cfg(any(feature = "http", feature = "http-blocking"))]
             InlineError::Network { error, .. } => Some(error),
             InlineError::MissingStyleSheet { .. } | InlineError::ParseError(_) => None,
         }
@@ -52,7 +52,7 @@ impl Display for InlineError {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         match self {
             Self::IO(error) => error.fmt(f),
-            #[cfg(feature = "http")]
+            #[cfg(any(feature = "http", feature = "http-blocking"))]
             Self::Network { error, location } => f.write_fmt(format_args!("{error}: {location}")),
             Self::ParseError(error) => f.write_str(error),
             Self::MissingStyleSheet { path } => {
diff --git a/css-inline/src/lib.rs b/css-inline/src/lib.rs
diff --git a/css-inline/src/main.rs b/css-inline/src/main.rs
diff --git a/css-inline/src/resolver.rs b/css-inline/src/resolver.rs
diff --git a/css-inline/tests/test_inlining.rs b/css-inline/tests/test_inlining.rs
diff --git a/css-inline/tests/test_selectors.rs b/css-inline/tests/test_selectors.rs
diff --git a/css-inline/tests/utils.rs b/css-inline/tests/utils.rs
diff --git a/profiler/src/main.rs b/profiler/src/main.rs

Original file line number	Diff line number	Diff line change
`@@ -60,6 +60,6 @@ export function inline(html: string, options?: InlineOptions): string;`
`60`	`60`	`export function version(): string;"#;`
`61`	`61`
`62`	`62`	`fn inline_inner(html: String, options: Options) -> std::result::Result<String, errors::JsError> {`
`63`		`- let inliner = css_inline::CSSInliner::new(options.try_into()?);`
	`63`	`+ let inliner = css_inline::blocking::CSSInliner::new(options.try_into()?);`
`64`	`64`	`Ok(inliner.inline(&html).map_err(errors::InlineError)?)`
`65`	`65`	`}`