selma 0.4.15 → 0.5.1

data/ext/selma/src/rewriter.rs

@@ -5,7 +5,7 @@ use lol_html::{
     Settings,
 };
 use magnus::{
-    exception, function, gc, method,
+    function, gc, method,
     r_hash::ForEach,
     scan_args,
     typed_data::Obj,
@@ -34,7 +34,11 @@ use crate::{
 #[derive(Clone)]
 pub struct Handler {
     rb_handler: Opaque<Value>,
-    rb_selector: Opaque<Obj<SelmaSelector>>,
+    // Store the selector's data by value (Rust-owned). The `#selector` method may return a
+    // freshly-built `Selma::Selector` that nothing else on the Ruby side references; keeping a
+    // `Obj`/`Opaque` handle to it would make its lifetime depend on GC (use-after-free if it is
+    // collected while the Rewriter is alive). We only ever read Rust data off it, so clone it.
+    selector: SelmaSelector,
     // total_element_handler_calls: usize,
     // total_elapsed_element_handlers: f64,
 
@@ -43,7 +47,8 @@ pub struct Handler {
 }
 
 struct RewriterOptions {
-    memory_options: MemorySettings,
+    max_allowed_memory_usage: usize,
+    preallocated_parsing_buffer_size: usize,
 }
 
 pub struct Rewriter {
@@ -84,12 +89,13 @@ impl SelmaRewriter {
     /// @return [Selma::Rewriter]
     fn new(args: &[Value]) -> Result<Self, magnus::Error> {
         let (rb_sanitizer, rb_handlers, rb_options) = Self::scan_parse_args(args)?;
+        let ruby = Ruby::get().unwrap();
 
         let sanitizer = match rb_sanitizer {
             None => {
                 // no `sanitizer:` kwarg provided, use default
                 let default_sanitizer = SelmaSanitizer::new(&[])?;
-                let wrapped_sanitizer = Obj::wrap(default_sanitizer);
+                let wrapped_sanitizer = ruby.obj_wrap(default_sanitizer);
                 // wrapped_sanitizer.funcall::<&str, (), Value>("setup", ())?;
                 Some(wrapped_sanitizer.deref().to_owned())
             }
@@ -106,7 +112,7 @@ impl SelmaRewriter {
                     if !rb_handler.respond_to("selector", true).unwrap() {
                         let classname = unsafe { rb_handler.classname() };
                         return Err(magnus::Error::new(
-                            exception::no_method_error(),
+                            ruby.exception_no_method_error(),
                             format!(
                                 "Could not call #selector on {classname:?}; is this an object that defines it?",
 
@@ -117,7 +123,7 @@ impl SelmaRewriter {
                     let rb_selector: Obj<SelmaSelector> = match rb_handler.funcall("selector", ()) {
                         Err(err) => {
                             return Err(magnus::Error::new(
-                                exception::type_error(),
+                                ruby.exception_type_error(),
                                 format!("Error instantiating selector: {err:?}"),
                             ));
                         }
@@ -125,7 +131,9 @@ impl SelmaRewriter {
                     };
                     let handler = Handler {
                         rb_handler: Opaque::from(rb_handler),
-                        rb_selector: Opaque::from(rb_selector),
+                        // clone the selector's data out of the Ruby object right away so the
+                        // Handler no longer depends on that object surviving GC (see struct docs)
+                        selector: (*rb_selector).clone(),
                         // total_element_handler_calls: 0,
                         // total_elapsed_element_handlers: 0.0,
 
@@ -140,7 +148,7 @@ impl SelmaRewriter {
 
         if sanitizer.is_none() && handlers.is_empty() {
             return Err(magnus::Error::new(
-                exception::arg_error(),
+                ruby.exception_arg_error(),
                 "Must provide a sanitizer or a handler",
             ));
         }
@@ -151,58 +159,55 @@ impl SelmaRewriter {
             None => {}
             Some(options) => {
                 options.foreach(|key: Symbol, value: RHash| {
+                    let ruby = Ruby::get().unwrap();
                     let key = key.to_string();
                     match key.as_str() {
                         "memory" => {
-                            let max_allowed_memory_usage = value.get(Symbol::new("max_allowed_memory_usage"));
-                            if max_allowed_memory_usage.is_some() {
-                                let max_allowed_memory_usage = max_allowed_memory_usage.unwrap();
+                            if let Some(max_allowed_memory_usage) = value.get(ruby.to_symbol("max_allowed_memory_usage")) {
                                 let max_allowed_memory_usage =
                                     Integer::from_value(max_allowed_memory_usage);
-                                if max_allowed_memory_usage.is_some() {
-                                    match max_allowed_memory_usage.unwrap().to_u64() {
+                                if let Some(max_allowed_memory_usage) = max_allowed_memory_usage {
+                                    match max_allowed_memory_usage.to_u64() {
                                         Ok(max_allowed_memory_usage) => {
-                                            rewriter_options.memory_options.max_allowed_memory_usage =
+                                            rewriter_options.max_allowed_memory_usage =
                                                 max_allowed_memory_usage as usize;
                                         }
                                         Err(_e) => {
                                             return Err(magnus::Error::new(
-                                                exception::arg_error(),
+                                                ruby.exception_arg_error(),
                                                 "max_allowed_memory_usage must be a positive integer",
                                             ));
                                         }
                                     }
                                 } else {
-                                    rewriter_options.memory_options.max_allowed_memory_usage = MemorySettings::default().max_allowed_memory_usage;
+                                    rewriter_options.max_allowed_memory_usage = RewriterOptions::DEFAULT_MAX_ALLOWED_MEMORY_USAGE;
                                 }
                             }
 
-                            let preallocated_parsing_buffer_size = value.get(Symbol::new("preallocated_parsing_buffer_size"));
-                            if preallocated_parsing_buffer_size.is_some() {
-                                let preallocated_parsing_buffer_size = preallocated_parsing_buffer_size.unwrap();
+                            if let Some(preallocated_parsing_buffer_size) = value.get(ruby.to_symbol("preallocated_parsing_buffer_size")) {
                                 let preallocated_parsing_buffer_size =
                                     Integer::from_value(preallocated_parsing_buffer_size);
-                                if preallocated_parsing_buffer_size.is_some() {
-                                    match preallocated_parsing_buffer_size.unwrap().to_u64() {
+                                if let Some(preallocated_parsing_buffer_size) = preallocated_parsing_buffer_size {
+                                    match preallocated_parsing_buffer_size.to_u64() {
                                         Ok(preallocated_parsing_buffer_size) => {
-                                            rewriter_options.memory_options.preallocated_parsing_buffer_size =
+                                            rewriter_options.preallocated_parsing_buffer_size =
                                                 preallocated_parsing_buffer_size as usize;
                                         }
                                         Err(_e) => {
                                             return Err(magnus::Error::new(
-                                                exception::arg_error(),
+                                                ruby.exception_arg_error(),
                                                 "preallocated_parsing_buffer_size must be a positive integer",
                                             ));
                                         }
                                     }
                                 } else {
-                                    rewriter_options.memory_options.preallocated_parsing_buffer_size = MemorySettings::default().preallocated_parsing_buffer_size;
+                                    rewriter_options.preallocated_parsing_buffer_size = RewriterOptions::DEFAULT_PREALLOCATED_PARSING_BUFFER_SIZE;
                                 }
                             }
                         }
                         _ => {
                             return Err(magnus::Error::new(
-                                exception::arg_error(),
+                                ruby.exception_arg_error(),
                                 format!("Unknown option: {key:?}"),
                             ));
                         }
@@ -212,13 +217,11 @@ impl SelmaRewriter {
             }
         }
 
-        if rewriter_options
-            .memory_options
-            .preallocated_parsing_buffer_size
-            > rewriter_options.memory_options.max_allowed_memory_usage
+        if rewriter_options.preallocated_parsing_buffer_size
+            > rewriter_options.max_allowed_memory_usage
         {
             return Err(magnus::Error::new(
-                exception::arg_error(),
+                ruby.exception_arg_error(),
                 "max_allowed_memory_usage must be greater than preallocated_parsing_buffer_size",
             ));
         }
@@ -305,7 +308,7 @@ impl SelmaRewriter {
                 None => match String::from_utf8(rewritten_html) {
                     Ok(output) => Ok(output),
                     Err(err) => Err(magnus::Error::new(
-                        exception::runtime_error(),
+                        Ruby::get().unwrap().exception_runtime_error(),
                         format!("{err:?}"),
                     )),
                 },
@@ -342,7 +345,7 @@ impl SelmaRewriter {
             Ok(rewritten_html) => match String::from_utf8(rewritten_html) {
                 Ok(output) => Ok(output),
                 Err(err) => Err(magnus::Error::new(
-                    exception::runtime_error(),
+                    Ruby::get().unwrap().exception_runtime_error(),
                     format!("{err:?}"),
                 )),
             },
@@ -366,55 +369,42 @@ impl SelmaRewriter {
         handlers.iter().for_each(|handler| {
             let element_stack: Rc<RefCell<Vec<String>>> = Rc::new(RefCell::new(vec![]));
 
-            let ruby = Ruby::get().unwrap();
-
-            let selector = ruby.get_inner(handler.rb_selector);
+            let selector = &handler.selector;
 
             // TODO: test final raise by simulating errors
-            if selector.match_element().is_some() {
+            if let Some(match_element) = selector.match_element() {
                 let closure_element_stack = element_stack.clone();
 
-                element_content_handlers.push(element!(
-                    selector.match_element().unwrap(),
-                    move |el| {
-                        match Self::process_element_handlers(
-                            handler,
-                            el,
-                            &closure_element_stack.borrow(),
-                        ) {
-                            Ok(_) => Ok(()),
-                            Err(err) => Err(err.to_string().into()),
-                        }
+                element_content_handlers.push(element!(match_element, move |el| {
+                    match Self::process_element_handlers(
+                        handler,
+                        el,
+                        &closure_element_stack.borrow(),
+                    ) {
+                        Ok(_) => Ok(()),
+                        Err(err) => Err(err.to_string().into()),
                     }
-                ));
+                }));
             }
 
-            if selector.match_text_within().is_some() {
+            if let Some(match_text_within) = selector.match_text_within() {
                 let closure_element_stack = element_stack.clone();
 
-                element_content_handlers.push(text!(
-                    selector.match_text_within().unwrap(),
-                    move |text| {
-                        let element_stack = closure_element_stack.as_ref().borrow();
-                        if selector.ignore_text_within().is_some() {
-                            // check if current tag is a tag we should be ignoring text within;
-                            // also checks if tag is within an ancestery of ignored tags
-                            if selector
-                                .ignore_text_within()
-                                .unwrap()
-                                .iter()
-                                .any(|t| element_stack.contains(t))
-                            {
-                                return Ok(());
-                            }
+                element_content_handlers.push(text!(match_text_within, move |text| {
+                    let element_stack = closure_element_stack.as_ref().borrow();
+                    // check if current tag is a tag we should be ignoring text within;
+                    // also checks if tag is within an ancestery of ignored tags
+                    if let Some(ignore_text_within) = selector.ignore_text_within() {
+                        if ignore_text_within.iter().any(|t| element_stack.contains(t)) {
+                            return Ok(());
                         }
+                    }
 
-                        match Self::process_text_handlers(handler, text) {
-                            Ok(_) => Ok(()),
-                            Err(err) => Err(err.to_string().into()),
-                        }
+                    match Self::process_text_handlers(handler, text) {
+                        Ok(_) => Ok(()),
+                        Err(err) => Err(err.to_string().into()),
                     }
-                ));
+                }));
             }
 
             // we need to check *every* element we iterate over, to create a stack of elements
@@ -430,14 +420,12 @@ impl SelmaRewriter {
 
                 let closure_element_stack = element_stack.clone();
 
-                if let Some(end_tag_handlers) = el.end_tag_handlers() {
-                    end_tag_handlers.push(lol_html::EndTagHandler::into(Box::new(
-                        move |_end_tag| {
-                            closure_element_stack.as_ref().borrow_mut().pop();
-                            Ok(())
-                        },
-                    )));
-                }
+                let handler: lol_html::EndTagHandler<'static> = Box::new(move |_end_tag| {
+                    closure_element_stack.as_ref().borrow_mut().pop();
+                    Ok(())
+                });
+                // ignore void elements (lol_html's void list may differ from selma's `self_closing`)
+                let _ = el.on_end_tag(handler);
 
                 Ok(())
             }));
@@ -460,20 +448,21 @@ impl SelmaRewriter {
         let binding = &self.0.borrow();
         let mut output = vec![];
         {
-            let mut rewriter = HtmlRewriter::new(
-                Settings {
-                    document_content_handlers,
-                    element_content_handlers,
-                    memory_settings: Self::get_memory_options(binding),
-                    ..Settings::default()
-                },
-                |c: &[u8]| output.extend_from_slice(c),
-            );
+            let mut settings =
+                Settings::new().with_memory_settings(Self::get_memory_options(binding));
+            for handler in document_content_handlers {
+                settings = settings.append_document_content_handler(handler);
+            }
+            for handler in element_content_handlers {
+                settings = settings.append_element_content_handler(handler);
+            }
+
+            let mut rewriter = HtmlRewriter::new(settings, |c: &[u8]| output.extend_from_slice(c));
             match rewriter.write(html) {
                 Ok(_) => {}
                 Err(err) => {
                     return Err(magnus::Error::new(
-                        exception::runtime_error(),
+                        Ruby::get().unwrap().exception_runtime_error(),
                         format!("{err:?}"),
                     ));
                 }
@@ -487,15 +476,13 @@ impl SelmaRewriter {
         element: &mut Element,
         ancestors: &[String],
     ) -> Result<(), magnus::Error> {
-        let rb_handler = handler.rb_handler.into_value();
+        let ruby = Ruby::get().unwrap();
+        let rb_handler = handler.rb_handler.into_value_with(&ruby);
 
         // if `on_end_tag` function is defined, call it
         if rb_handler.respond_to(Self::SELMA_ON_END_TAG, true).unwrap() {
-            // TODO: error here is an "EndTagError"
             element
-                .end_tag_handlers()
-                .unwrap()
-                .push(Box::new(move |end_tag| {
+                .on_end_tag(Box::new(move |end_tag| {
                     let (ref_wrap, anchor) = NativeRefWrap::wrap(end_tag);
 
                     let rb_end_tag = SelmaHTMLEndTag::new(ref_wrap);
@@ -509,7 +496,13 @@ impl SelmaRewriter {
                         Ok(_) => Ok(()),
                         Err(err) => Err(err.to_string().into()),
                     }
-                }));
+                }))
+                .map_err(|err| {
+                    magnus::Error::new(
+                        Ruby::get().unwrap().exception_runtime_error(),
+                        err.to_string(),
+                    )
+                })?;
         }
 
         let (ref_wrap, anchor) = NativeRefWrap::wrap(element);
@@ -521,7 +514,7 @@ impl SelmaRewriter {
         match result {
             Ok(_) => Ok(()),
             Err(err) => Err(magnus::Error::new(
-                exception::runtime_error(),
+                ruby.exception_runtime_error(),
                 format!("{err:?}"),
             )),
         }
@@ -531,7 +524,8 @@ impl SelmaRewriter {
         handler: &Handler,
         text_chunk: &mut TextChunk,
     ) -> Result<(), magnus::Error> {
-        let rb_handler = handler.rb_handler.into_value();
+        let ruby = Ruby::get().unwrap();
+        let rb_handler = handler.rb_handler.into_value_with(&ruby);
 
         // prevents missing `handle_text_chunk` function
         let content = text_chunk.as_str();
@@ -553,32 +547,38 @@ impl SelmaRewriter {
         match result {
             Ok(_) => Ok(()),
             Err(err) => Err(magnus::Error::new(
-                exception::runtime_error(),
+                ruby.exception_runtime_error(),
                 format!("{err:?}"),
             )),
         }
     }
 
     fn get_memory_options(binding: &Ref<Rewriter>) -> MemorySettings {
-        let options = &binding.options.memory_options;
-        MemorySettings {
-            max_allowed_memory_usage: options.max_allowed_memory_usage,
-            preallocated_parsing_buffer_size: options.preallocated_parsing_buffer_size,
-        }
+        let options = &binding.options;
+        MemorySettings::new()
+            .with_max_allowed_memory_usage(options.max_allowed_memory_usage)
+            .with_preallocated_parsing_buffer_size(options.preallocated_parsing_buffer_size)
     }
 }
 
 impl RewriterOptions {
+    // Mirrors lol_html's `MemorySettings` defaults, which are no longer exposed as
+    // public fields as of lol_html 3.0 (settings are now consuming builders).
+    const DEFAULT_MAX_ALLOWED_MEMORY_USAGE: usize = usize::MAX;
+    const DEFAULT_PREALLOCATED_PARSING_BUFFER_SIZE: usize = 1024;
+
     pub fn new() -> Self {
         Self {
-            memory_options: MemorySettings::default(),
+            max_allowed_memory_usage: Self::DEFAULT_MAX_ALLOWED_MEMORY_USAGE,
+            preallocated_parsing_buffer_size: Self::DEFAULT_PREALLOCATED_PARSING_BUFFER_SIZE,
         }
     }
 }
 
 pub fn init(m_selma: RModule) -> Result<(), magnus::Error> {
+    let ruby = Ruby::get().unwrap();
     let c_rewriter = m_selma
-        .define_class("Rewriter", magnus::class::object())
+        .define_class("Rewriter", ruby.class_object())
         .expect("cannot define class Selma::Rewriter");
 
     c_rewriter.define_singleton_method("new", function!(SelmaRewriter::new, -1))?;

data/ext/selma/src/sanitizer.rs

@@ -5,7 +5,7 @@ use lol_html::{
     html_content::{Comment, ContentType, Doctype, Element, EndTag},
 };
 use magnus::{
-    class, eval, exception, function, method,
+    eval, function, method,
     r_hash::ForEach,
     scan_args,
     value::{Opaque, ReprValue},
@@ -125,22 +125,22 @@ impl SelmaSanitizer {
                 allowed_protocols.foreach(|element_name: String, protocols: RHash| {
                     protocols.foreach(|attribute_name: String, protocol_list: Value| {
                         let protocols: RArray;
-                        if protocol_list.is_kind_of(class::array()) {
+                        if protocol_list.is_kind_of(ruby.class_array()) {
                             protocols = RArray::from_value(protocol_list).unwrap();
                             if protocols.includes(ruby.to_symbol("all")) {
                                 return Err(magnus::Error::new(
-                                    exception::arg_error(),
+                                    ruby.exception_arg_error(),
                                     "`:all` must be passed outside of an array".to_string(),
                                 ));
                             }
-                        } else if protocol_list.is_kind_of(class::symbol())
+                        } else if protocol_list.is_kind_of(ruby.class_symbol())
                             && Symbol::from_value(protocol_list) == eval(":all").unwrap()
                         {
-                            protocols = RArray::new();
+                            protocols = ruby.ary_new();
                             protocols.push(ruby.to_symbol("all"))?;
                         } else {
                             return Err(magnus::Error::new(
-                                exception::arg_error(),
+                                ruby.exception_arg_error(),
                                 "Protocol list must be an array, or just `:all`".to_string(),
                             ));
                         }
@@ -220,15 +220,15 @@ impl SelmaSanitizer {
         //  end
         // end
         if let Some(remove_contents) = config.get(ruby.to_symbol("remove_contents")) {
-            if remove_contents.is_kind_of(class::true_class())
-                || remove_contents.is_kind_of(class::false_class())
+            if remove_contents.is_kind_of(ruby.class_true_class())
+                || remove_contents.is_kind_of(ruby.class_false_class())
             {
                 Self::set_all_flags(
                     flags,
                     Self::SELMA_SANITIZER_REMOVE_CONTENTS,
                     remove_contents.to_bool(),
                 );
-            } else if remove_contents.is_kind_of(class::array()) {
+            } else if remove_contents.is_kind_of(ruby.class_array()) {
                 let elements = RArray::from_value(remove_contents).unwrap();
                 elements
                     .into_iter()
@@ -245,7 +245,7 @@ impl SelmaSanitizer {
                     });
             } else {
                 return Err(magnus::Error::new(
-                    exception::arg_error(),
+                    ruby.exception_arg_error(),
                     "remove_contents must be `true`, `false`, or an array".to_string(),
                 ));
             }
@@ -354,11 +354,12 @@ impl SelmaSanitizer {
         attr_name: String,
         allow_list: RArray,
     ) {
+        let ruby = Ruby::get().unwrap();
         let protocol_sanitizers = &mut element_sanitizer.protocol_sanitizers.borrow_mut();
 
         for allowed_protocol in allow_list.into_iter() {
             let protocol_list = protocol_sanitizers.get_mut(&attr_name);
-            if allowed_protocol.is_kind_of(class::string()) {
+            if allowed_protocol.is_kind_of(ruby.class_string()) {
                 match protocol_list {
                     None => {
                         protocol_sanitizers
@@ -366,7 +367,7 @@ impl SelmaSanitizer {
                     }
                     Some(protocol_list) => protocol_list.push(allowed_protocol.to_string()),
                 }
-            } else if allowed_protocol.is_kind_of(class::symbol()) {
+            } else if allowed_protocol.is_kind_of(ruby.class_symbol()) {
                 let protocol_config = allowed_protocol.inspect();
                 if protocol_config == ":relative" {
                     match protocol_list {
@@ -685,13 +686,11 @@ impl SelmaSanitizer {
 
     fn check_if_end_tag_needs_removal(element: &mut Element) {
         if element.removed() && !crate::tags::Tag::tag_from_element(element).self_closing {
-            element
-                .end_tag_handlers()
-                .unwrap()
-                .push(Box::new(move |end| {
-                    Self::remove_end_tag(end);
-                    Ok(())
-                }));
+            // ignore void elements (lol_html's void list may differ from selma's `self_closing`)
+            let _ = element.on_end_tag(Box::new(move |end| {
+                Self::remove_end_tag(end);
+                Ok(())
+            }));
         }
     }
 
@@ -710,8 +709,9 @@ impl SelmaSanitizer {
 }
 
 pub fn init(m_selma: RModule) -> Result<(), magnus::Error> {
+    let ruby = Ruby::get().unwrap();
     let c_sanitizer = m_selma
-        .define_class("Sanitizer", magnus::class::object())
+        .define_class("Sanitizer", ruby.class_object())
         .expect("cannot define class Selma::Sanitizer");
 
     c_sanitizer.define_singleton_method("new", function!(SelmaSanitizer::new, -1))?;

data/ext/selma/src/selector.rs

@@ -1,4 +1,4 @@
-use magnus::{exception, function, scan_args, Error, Module, Object, RModule, Value};
+use magnus::{function, scan_args, Error, Module, Object, RModule, Ruby, Value};
 
 #[derive(Clone, Debug)]
 #[magnus::wrap(class = "Selma::Selector")]
@@ -14,31 +14,30 @@ impl SelmaSelector {
     fn new(args: &[Value]) -> Result<Self, Error> {
         let (match_element, match_text_within, rb_ignore_text_within) =
             Self::scan_parse_args(args)?;
+        let ruby = Ruby::get().unwrap();
 
         if match_element.is_none() && match_text_within.is_none() {
             return Err(Error::new(
-                exception::arg_error(),
+                ruby.exception_arg_error(),
                 "Neither `match_element` nor `match_text_within` option given",
             ));
         }
 
         // FIXME: not excited about this double parse work (`element!` does it too),
         // but at least we can bail ASAP if the CSS is invalid
-        if match_element.is_some() {
-            let css = match_element.as_ref().unwrap();
+        if let Some(css) = &match_element {
             if css.parse::<lol_html::Selector>().is_err() {
                 return Err(Error::new(
-                    exception::arg_error(),
+                    ruby.exception_arg_error(),
                     format!("Could not parse `match_element` (`{css:?}`) as valid CSS"),
                 ));
             }
         }
 
-        if match_text_within.is_some() {
-            let css = match_text_within.as_ref().unwrap();
+        if let Some(css) = &match_text_within {
             if css.parse::<lol_html::Selector>().is_err() {
                 return Err(Error::new(
-                    exception::arg_error(),
+                    ruby.exception_arg_error(),
                     format!("Could not parse `match_text_within` (`{css:?}`) as valid CSS",),
                 ));
             }
@@ -88,22 +87,23 @@ impl SelmaSelector {
         Ok((match_element, match_text_within, rb_ignore_text_within))
     }
 
-    pub fn match_element(&self) -> Option<String> {
-        self.match_element.clone()
+    pub fn match_element(&self) -> Option<&str> {
+        self.match_element.as_deref()
     }
 
-    pub fn match_text_within(&self) -> Option<String> {
-        self.match_text_within.clone()
+    pub fn match_text_within(&self) -> Option<&str> {
+        self.match_text_within.as_deref()
     }
 
-    pub fn ignore_text_within(&self) -> Option<Vec<String>> {
-        self.ignore_text_within.clone()
+    pub fn ignore_text_within(&self) -> Option<&[String]> {
+        self.ignore_text_within.as_deref()
     }
 }
 
 pub fn init(m_selma: RModule) -> Result<(), Error> {
+    let ruby = Ruby::get().unwrap();
     let c_selector = m_selma
-        .define_class("Selector", magnus::class::object())
+        .define_class("Selector", ruby.class_object())
         .expect("cannot define class Selma::Selector");
 
     c_selector.define_singleton_method("new", function!(SelmaSelector::new, -1))?;

data/lib/selma/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Selma
-  VERSION = "0.4.15"
+  VERSION = "0.5.1"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: selma
 version: !ruby/object:Gem::Version
-  version: 0.4.15
+  version: 0.5.1
 platform: ruby
 authors:
 - Garen J. Torikian
@@ -112,7 +112,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '3.4'
 requirements: []
-rubygems_version: 4.0.3
+rubygems_version: 4.0.10
 specification_version: 4
 summary: Selma selects and matches HTML nodes using CSS rules. Backed by Rust's lol_html
   parser.