css_inline 0.17.0 → 0.18.0

data/ext/css_inline/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
-name = "css-inline"
-version = "0.17.0"
+name = "css-inline-ruby"
+version = "0.18.0"
 authors = ["Dmitry Dygalo <dmitry@dygalo.dev>"]
 edition = "2021"
 readme = "README.rdoc"
@@ -9,17 +9,17 @@ repository = "https://github.com/Stranger6667/css-inline"
 keywords = ["css", "html", "email", "stylesheet", "inlining"]
 categories = ["web-programming"]
 license = "MIT"
-rust-version = "1.82"
+rust-version = "1.83"
 
 [lib]
 name = "css_inline"
 crate-type = ["cdylib"]
 
 [dependencies]
-magnus = "0.7"
+magnus = "0.8"
 rayon = "1"
 
 [dependencies.css-inline]
-version = "0.17"
+version = "0.18.0"
 default-features = false
 features = ["http", "file", "stylesheet-cache"]

data/ext/css_inline/src/lib.rs

@@ -27,11 +27,11 @@
 )]
 use css_inline as rust_inline;
 use magnus::{
-    class, define_module, function, method,
+    function, method,
     prelude::*,
     scan_args::{get_kwargs, scan_args, Args},
     typed_data::Obj,
-    DataTypeFunctions, RHash, TypedData, Value,
+    DataTypeFunctions, RHash, Ruby, TryConvert, TypedData, Value,
 };
 use rayon::prelude::*;
 use std::{
@@ -42,52 +42,72 @@ use std::{
 
 type RubyResult<T> = Result<T, magnus::Error>;
 
+#[allow(clippy::struct_excessive_bools)]
+struct Options {
+    /// Whether to inline CSS from "style" tags.
+    ///
+    /// Sometimes HTML may include a lot of boilerplate styles, that are not applicable in every
+    /// scenario, and it is useful to ignore them and use `extra_css` instead.
+    inline_style_tags: Option<bool>,
+    /// Keep "style" tags after inlining.
+    keep_style_tags: Option<bool>,
+    /// Keep "link" tags after inlining.
+    keep_link_tags: Option<bool>,
+    /// Keep "at-rules" after inlining.
+    keep_at_rules: Option<bool>,
+    /// Remove trailing semicolons and spaces between properties and values.
+    minify_css: Option<bool>,
+    /// Used for loading external stylesheets via relative URLs.
+    base_url: Option<String>,
+    /// Whether remote stylesheets should be loaded or not.
+    load_remote_stylesheets: Option<bool>,
+    /// An LRU Cache for external stylesheets.
+    cache: Option<Obj<StylesheetCache>>,
+    /// Additional CSS to inline.
+    extra_css: Option<String>,
+    /// Pre-allocate capacity for HTML nodes during parsing.
+    /// It can improve performance when you have an estimate of the number of nodes in your HTML document.
+    preallocate_node_capacity: Option<usize>,
+}
+
+impl TryConvert for Options {
+    fn try_convert(v: Value) -> Result<Self, magnus::Error> {
+        let h = RHash::try_convert(v)?;
+        let ruby = Ruby::get_with(v);
+        Ok(Self {
+            inline_style_tags: h.aref::<_, Option<bool>>(ruby.to_symbol("inline_style_tags"))?,
+            keep_style_tags: h.aref::<_, Option<bool>>(ruby.to_symbol("keep_style_tags"))?,
+            keep_link_tags: h.aref::<_, Option<bool>>(ruby.to_symbol("keep_link_tags"))?,
+            keep_at_rules: h.aref::<_, Option<bool>>(ruby.to_symbol("keep_at_rules"))?,
+            minify_css: h.aref::<_, Option<bool>>(ruby.to_symbol("minify_css"))?,
+            base_url: h.aref::<_, Option<String>>(ruby.to_symbol("base_url"))?,
+            load_remote_stylesheets: h
+                .aref::<_, Option<bool>>(ruby.to_symbol("load_remote_stylesheets"))?,
+            cache: h.aref::<_, Option<Obj<StylesheetCache>>>(ruby.to_symbol("cache"))?,
+            extra_css: h.aref::<_, Option<String>>(ruby.to_symbol("extra_css"))?,
+            preallocate_node_capacity: h
+                .aref::<_, Option<usize>>(ruby.to_symbol("preallocate_node_capacity"))?,
+        })
+    }
+}
+
 fn parse_options<Req>(
     args: &Args<Req, (), (), (), RHash, ()>,
 ) -> RubyResult<rust_inline::InlineOptions<'static>> {
-    let kwargs = get_kwargs::<
-        _,
-        (),
-        (
-            Option<bool>,
-            Option<bool>,
-            Option<bool>,
-            Option<bool>,
-            Option<String>,
-            Option<bool>,
-            Option<Obj<StylesheetCache>>,
-            Option<String>,
-            Option<usize>,
-        ),
-        (),
-    >(
-        args.keywords,
-        &[],
-        &[
-            "inline_style_tags",
-            "keep_style_tags",
-            "keep_link_tags",
-            "keep_at_rules",
-            "base_url",
-            "load_remote_stylesheets",
-            "cache",
-            "extra_css",
-            "preallocate_node_capacity",
-        ],
-    )?;
-    let kwargs = kwargs.optional;
+    let kwargs: Options = Options::try_convert(args.keywords.as_value())?;
     Ok(rust_inline::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),
-        keep_at_rules: kwargs.3.unwrap_or(false),
-        base_url: parse_url(kwargs.4)?,
-        load_remote_stylesheets: kwargs.5.unwrap_or(true),
+        inline_style_tags: kwargs.inline_style_tags.unwrap_or(true),
+        keep_style_tags: kwargs.keep_style_tags.unwrap_or(false),
+        keep_link_tags: kwargs.keep_link_tags.unwrap_or(false),
+        keep_at_rules: kwargs.keep_at_rules.unwrap_or(false),
+        minify_css: kwargs.minify_css.unwrap_or(false),
+        base_url: parse_url(kwargs.base_url)?,
+        load_remote_stylesheets: kwargs.load_remote_stylesheets.unwrap_or(true),
         cache: kwargs
-            .6
+            .cache
             .map(|cache| Mutex::new(rust_inline::StylesheetCache::new(cache.size))),
-        extra_css: kwargs.7.map(Cow::Owned),
-        preallocate_node_capacity: kwargs.8.unwrap_or(32),
+        extra_css: kwargs.extra_css.map(Cow::Owned),
+        preallocate_node_capacity: kwargs.preallocate_node_capacity.unwrap_or(32),
         resolver: Arc::new(rust_inline::DefaultStylesheetResolver),
     })
 }
@@ -101,8 +121,9 @@ struct StylesheetCache {
 impl StylesheetCache {
     fn new(args: &[Value]) -> RubyResult<StylesheetCache> {
         fn error() -> magnus::Error {
+            let ruby = Ruby::get().expect("Always called from a Ruby thread");
             magnus::Error::new(
-                magnus::exception::arg_error(),
+                ruby.exception_arg_error(),
                 "Cache size must be an integer greater than zero",
             )
         }
@@ -124,19 +145,19 @@ struct InlineErrorWrapper(rust_inline::InlineError);
 
 impl From<InlineErrorWrapper> for magnus::Error {
     fn from(error: InlineErrorWrapper) -> Self {
+        let ruby = Ruby::get().expect("Always called from a Ruby thread");
         match error.0 {
             rust_inline::InlineError::IO(error) => {
-                magnus::Error::new(magnus::exception::arg_error(), error.to_string())
+                magnus::Error::new(ruby.exception_arg_error(), error.to_string())
+            }
+            rust_inline::InlineError::Network { error, location } => {
+                magnus::Error::new(ruby.exception_arg_error(), format!("{error}: {location}"))
             }
-            rust_inline::InlineError::Network { error, location } => magnus::Error::new(
-                magnus::exception::arg_error(),
-                format!("{error}: {location}"),
-            ),
             rust_inline::InlineError::ParseError(message) => {
-                magnus::Error::new(magnus::exception::arg_error(), message.to_string())
+                magnus::Error::new(ruby.exception_arg_error(), message.to_string())
             }
             rust_inline::InlineError::MissingStyleSheet { .. } => {
-                magnus::Error::new(magnus::exception::arg_error(), error.0.to_string())
+                magnus::Error::new(ruby.exception_arg_error(), error.0.to_string())
             }
         }
     }
@@ -149,8 +170,9 @@ struct UrlError {
 
 impl From<UrlError> for magnus::Error {
     fn from(error: UrlError) -> magnus::Error {
+        let ruby = Ruby::get().expect("Always called from a Ruby thread");
         magnus::Error::new(
-            magnus::exception::arg_error(),
+            ruby.exception_arg_error(),
             format!("{}: {}", error.error, error.url),
         )
     }
@@ -256,8 +278,8 @@ fn inline_many_fragments_impl(
 }
 
 #[magnus::init(name = "css_inline")]
-fn init() -> RubyResult<()> {
-    let module = define_module("CSSInline")?;
+fn init(ruby: &Ruby) -> RubyResult<()> {
+    let module = ruby.define_module("CSSInline")?;
 
     module.define_module_function("inline", function!(inline, -1))?;
     module.define_module_function("inline_fragment", function!(inline_fragment, -1))?;
@@ -267,7 +289,7 @@ fn init() -> RubyResult<()> {
         function!(inline_many_fragments, -1),
     )?;
 
-    let class = module.define_class("CSSInliner", class::object())?;
+    let class = module.define_class("CSSInliner", ruby.class_object())?;
     class.define_singleton_method("new", function!(CSSInliner::new, -1))?;
     class.define_method("inline", method!(CSSInliner::inline, 1))?;
     class.define_method("inline_fragment", method!(CSSInliner::inline_fragment, 2))?;
@@ -277,7 +299,7 @@ fn init() -> RubyResult<()> {
         method!(CSSInliner::inline_many_fragments, 2),
     )?;
 
-    let class = module.define_class("StylesheetCache", class::object())?;
+    let class = module.define_class("StylesheetCache", ruby.class_object())?;
     class.define_singleton_method("new", function!(StylesheetCache::new, -1))?;
     Ok(())
 }

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: css_inline
 version: !ruby/object:Gem::Version
-  version: 0.17.0
+  version: 0.18.0
 platform: ruby
 authors:
 - Dmitry Dygalo
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2025-07-26 00:00:00.000000000 Z
+date: 2025-11-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rb_sys
@@ -141,7 +141,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: 3.3.26
 requirements:
-- Rust >= 1.82
+- Rust >= 1.83
 rubygems_version: 3.4.19
 signing_key: 
 specification_version: 4