selma 0.4.14 → 0.5.0

data/ext/selma/src/html/element.rs

@@ -2,7 +2,7 @@ use std::cell::RefCell;
 
 use crate::native_ref_wrap::NativeRefWrap;
 use lol_html::html_content::Element;
-use magnus::{exception, method, Error, Module, RArray, RClass, RHash, RString, Value};
+use magnus::{method, Error, Module, RArray, RClass, RHash, Ruby, Value};
 
 struct HTMLElement {
     element: NativeRefWrap<Element<'static, 'static>>,
@@ -29,7 +29,7 @@ impl SelmaHTMLElement {
         match binding.element.get() {
             Ok(e) => Ok(e.tag_name().to_string()),
             Err(_) => Err(Error::new(
-                exception::runtime_error(),
+                Ruby::get().unwrap().exception_runtime_error(),
                 "`tag_name` is not available",
             )),
         }
@@ -37,15 +37,19 @@ impl SelmaHTMLElement {
 
     fn set_tag_name(&self, name: String) -> Result<(), Error> {
         let mut binding = self.0.borrow_mut();
+        let ruby = Ruby::get().unwrap();
 
         if let Ok(element) = binding.element.get_mut() {
             match element.set_tag_name(&name) {
                 Ok(_) => Ok(()),
-                Err(err) => Err(Error::new(exception::runtime_error(), format!("{err:?}"))),
+                Err(err) => Err(Error::new(
+                    ruby.exception_runtime_error(),
+                    format!("{err:?}"),
+                )),
             }
         } else {
             Err(Error::new(
-                exception::runtime_error(),
+                ruby.exception_runtime_error(),
                 "`set_tag_name` is not available",
             ))
         }
@@ -58,7 +62,7 @@ impl SelmaHTMLElement {
             Ok(e.is_self_closing())
         } else {
             Err(Error::new(
-                exception::runtime_error(),
+                Ruby::get().unwrap().exception_runtime_error(),
                 "`is_self_closing` is not available",
             ))
         }
@@ -71,7 +75,7 @@ impl SelmaHTMLElement {
             Ok(e.has_attribute(&attr))
         } else {
             Err(Error::new(
-                exception::runtime_error(),
+                Ruby::get().unwrap().exception_runtime_error(),
                 "`is_self_closing` is not available",
             ))
         }
@@ -85,17 +89,18 @@ impl SelmaHTMLElement {
 
     fn set_attribute(&self, attr: String, value: String) -> Result<String, Error> {
         let mut binding = self.0.borrow_mut();
+        let ruby = Ruby::get().unwrap();
         if let Ok(element) = binding.element.get_mut() {
             match element.set_attribute(&attr, &value) {
                 Ok(_) => Ok(value),
                 Err(err) => Err(Error::new(
-                    exception::runtime_error(),
+                    ruby.exception_runtime_error(),
                     format!("AttributeNameError: {err:?}"),
                 )),
             }
         } else {
             Err(Error::new(
-                exception::runtime_error(),
+                ruby.exception_runtime_error(),
                 "`tag_name` is not available",
             ))
         }
@@ -111,7 +116,8 @@ impl SelmaHTMLElement {
 
     fn get_attributes(&self) -> Result<RHash, Error> {
         let binding = self.0.borrow();
-        let hash = RHash::new();
+        let ruby = Ruby::get().unwrap();
+        let hash = ruby.hash_new();
 
         if let Ok(e) = binding.element.get() {
             e.attributes()
@@ -121,7 +127,7 @@ impl SelmaHTMLElement {
                     Err(err) => panic!(
                         "{:?}",
                         Error::new(
-                            exception::runtime_error(),
+                            ruby.exception_runtime_error(),
                             format!("AttributeNameError: {err:?}"),
                         )
                     ),
@@ -132,17 +138,18 @@ impl SelmaHTMLElement {
 
     fn get_ancestors(&self) -> Result<RArray, Error> {
         let binding = self.0.borrow();
-        let array = RArray::new();
+        let ruby = Ruby::get().unwrap();
+        let array = ruby.ary_new();
 
         binding
             .ancestors
             .iter()
-            .for_each(|ancestor| match array.push(RString::new(ancestor)) {
+            .for_each(|ancestor| match array.push(ruby.str_new(ancestor)) {
                 Ok(_) => {}
                 Err(err) => {
                     panic!(
                         "{:?}",
-                        Error::new(exception::runtime_error(), format!("{err:?}"))
+                        Error::new(ruby.exception_runtime_error(), format!("{err:?}"))
                     )
                 }
             });
@@ -244,7 +251,7 @@ impl SelmaHTMLElement {
         match binding.element.get() {
             Ok(e) => Ok(e.removed()),
             Err(_) => Err(Error::new(
-                exception::runtime_error(),
+                Ruby::get().unwrap().exception_runtime_error(),
                 "`is_removed` is not available",
             )),
         }
@@ -252,8 +259,9 @@ impl SelmaHTMLElement {
 }
 
 pub fn init(c_html: RClass) -> Result<(), Error> {
+    let ruby = Ruby::get().unwrap();
     let c_element = c_html
-        .define_class("Element", magnus::class::object())
+        .define_class("Element", ruby.class_object())
         .expect("cannot define class Selma::HTML::Element");
 
     c_element.define_method("tag_name", method!(SelmaHTMLElement::tag_name, 0))?;

data/ext/selma/src/html/end_tag.rs

@@ -2,7 +2,7 @@ use std::cell::RefCell;
 
 use crate::native_ref_wrap::NativeRefWrap;
 use lol_html::html_content::EndTag;
-use magnus::{method, Error, Module, RClass};
+use magnus::{method, Error, Module, RClass, Ruby};
 
 struct HTMLEndTag {
     end_tag: NativeRefWrap<EndTag<'static>>,
@@ -25,8 +25,9 @@ impl SelmaHTMLEndTag {
 }
 
 pub fn init(c_html: RClass) -> Result<(), Error> {
+    let ruby = Ruby::get().unwrap();
     let c_end_tag = c_html
-        .define_class("EndTag", magnus::class::object())
+        .define_class("EndTag", ruby.class_object())
         .expect("cannot define class Selma::HTML::EndTag");
 
     c_end_tag.define_method("tag_name", method!(SelmaHTMLEndTag::tag_name, 0))?;

data/ext/selma/src/html/text_chunk.rs

@@ -2,7 +2,7 @@ use std::cell::RefCell;
 
 use crate::native_ref_wrap::NativeRefWrap;
 use lol_html::html_content::{TextChunk, TextType};
-use magnus::{exception, method, Error, Module, RClass, Symbol, Value};
+use magnus::{method, Error, Module, RClass, Ruby, Symbol, Value};
 
 struct HTMLTextChunk {
     text_chunk: NativeRefWrap<TextChunk<'static>>,
@@ -49,7 +49,7 @@ impl SelmaHTMLTextChunk {
             Ok(tc.as_str().to_string())
         } else {
             Err(Error::new(
-                exception::runtime_error(),
+                Ruby::get().unwrap().exception_runtime_error(),
                 "`to_s` is not available",
             ))
         }
@@ -57,19 +57,20 @@ impl SelmaHTMLTextChunk {
 
     fn text_type(&self) -> Result<Symbol, Error> {
         let binding = self.0.borrow();
+        let ruby = Ruby::get().unwrap();
 
         if let Ok(tc) = binding.text_chunk.get() {
             match tc.text_type() {
-                TextType::Data => Ok(Symbol::new("data")),
-                TextType::PlainText => Ok(Symbol::new("plain_text")),
-                TextType::RawText => Ok(Symbol::new("raw_text")),
-                TextType::ScriptData => Ok(Symbol::new("script")),
-                TextType::RCData => Ok(Symbol::new("rc_data")),
-                TextType::CDataSection => Ok(Symbol::new("cdata_section")),
+                TextType::Data => Ok(ruby.to_symbol("data")),
+                TextType::PlainText => Ok(ruby.to_symbol("plain_text")),
+                TextType::RawText => Ok(ruby.to_symbol("raw_text")),
+                TextType::ScriptData => Ok(ruby.to_symbol("script")),
+                TextType::RCData => Ok(ruby.to_symbol("rc_data")),
+                TextType::CDataSection => Ok(ruby.to_symbol("cdata_section")),
             }
         } else {
             Err(Error::new(
-                exception::runtime_error(),
+                ruby.exception_runtime_error(),
                 "`text_type` is not available",
             ))
         }
@@ -81,7 +82,7 @@ impl SelmaHTMLTextChunk {
         match binding.text_chunk.get() {
             Ok(tc) => Ok(tc.removed()),
             Err(_) => Err(Error::new(
-                exception::runtime_error(),
+                Ruby::get().unwrap().exception_runtime_error(),
                 "`is_removed` is not available",
             )),
         }
@@ -140,8 +141,9 @@ impl SelmaHTMLTextChunk {
 }
 
 pub fn init(c_html: RClass) -> Result<(), Error> {
+    let ruby = Ruby::get().unwrap();
     let c_text_chunk = c_html
-        .define_class("TextChunk", magnus::class::object())
+        .define_class("TextChunk", ruby.class_object())
         .expect("cannot define class Selma::HTML::TextChunk");
 
     c_text_chunk.define_method("to_s", method!(SelmaHTMLTextChunk::to_s, 0))?;

data/ext/selma/src/html.rs

@@ -1,12 +1,9 @@
-use magnus::{Error, Module, RModule};
-
-#[derive(Clone, Debug)]
-#[magnus::wrap(class = "Selma::HTML")]
-pub(crate) struct SelmaHTML {}
+use magnus::{Error, Module, RModule, Ruby};
 
 pub fn init(m_selma: RModule) -> Result<(), Error> {
+    let ruby = Ruby::get().unwrap();
     let c_html = m_selma
-        .define_class("HTML", magnus::class::object())
+        .define_class("HTML", ruby.class_object())
         .expect("cannot define class Selma::HTML");
 
     element::init(c_html).expect("cannot define Selma::HTML::Element class");

data/ext/selma/src/lib.rs

@@ -1,7 +1,7 @@
 extern crate core;
 
 use lol_html::html_content::ContentType;
-use magnus::{define_module, exception, scan_args, Error, Symbol, Value};
+use magnus::{scan_args, Error, Ruby, Symbol, Value};
 
 pub mod html;
 pub mod native_ref_wrap;
@@ -27,8 +27,9 @@ fn scan_text_args(args: &[Value]) -> Result<(String, ContentType), magnus::Error
     } else if as_sym_str == "html" {
         ContentType::Html
     } else {
+        let ruby = Ruby::get().unwrap();
         return Err(Error::new(
-            exception::runtime_error(),
+            ruby.exception_runtime_error(),
             format!("unknown symbol `{as_sym_str:?}`"),
         ));
     };
@@ -37,8 +38,10 @@ fn scan_text_args(args: &[Value]) -> Result<(String, ContentType), magnus::Error
 }
 
 #[magnus::init]
-fn init() -> Result<(), Error> {
-    let m_selma = define_module("Selma").expect("cannot define ::Selma module");
+fn init(ruby: &Ruby) -> Result<(), Error> {
+    let m_selma = ruby
+        .define_module("Selma")
+        .expect("cannot define ::Selma module");
 
     sanitizer::init(m_selma).expect("cannot define Selma::Sanitizer class");
     rewriter::init(m_selma).expect("cannot define Selma::Rewriter class");

data/ext/selma/src/native_ref_wrap.rs

@@ -39,7 +39,7 @@ pub struct NativeRefWrap<R> {
 }
 
 impl<R> NativeRefWrap<R> {
-    pub fn wrap<I>(inner: &mut I) -> (Self, Anchor) {
+    pub fn wrap<I>(inner: &mut I) -> (Self, Anchor<'_>) {
         let wrap = NativeRefWrap {
             inner_ptr: inner as *mut I as *mut R,
             poisoned: Arc::new(Mutex::new(false)),

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,
@@ -84,12 +84,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 +107,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 +118,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:?}"),
                             ));
                         }
@@ -140,7 +141,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,23 +152,22 @@ 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 =
                                                 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",
                                             ));
                                         }
@@ -177,20 +177,18 @@ impl SelmaRewriter {
                                 }
                             }
 
-                            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 =
                                                 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",
                                             ));
                                         }
@@ -202,7 +200,7 @@ impl SelmaRewriter {
                         }
                         _ => {
                             return Err(magnus::Error::new(
-                                exception::arg_error(),
+                                ruby.exception_arg_error(),
                                 format!("Unknown option: {key:?}"),
                             ));
                         }
@@ -218,7 +216,7 @@ impl SelmaRewriter {
             > rewriter_options.memory_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 +303,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 +340,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:?}"),
                 )),
             },
@@ -430,14 +428,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(())
             }));
@@ -473,7 +469,7 @@ impl SelmaRewriter {
                 Ok(_) => {}
                 Err(err) => {
                     return Err(magnus::Error::new(
-                        exception::runtime_error(),
+                        Ruby::get().unwrap().exception_runtime_error(),
                         format!("{err:?}"),
                     ));
                 }
@@ -487,15 +483,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 +503,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 +521,7 @@ impl SelmaRewriter {
         match result {
             Ok(_) => Ok(()),
             Err(err) => Err(magnus::Error::new(
-                exception::runtime_error(),
+                ruby.exception_runtime_error(),
                 format!("{err:?}"),
             )),
         }
@@ -531,7 +531,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,7 +554,7 @@ impl SelmaRewriter {
         match result {
             Ok(_) => Ok(()),
             Err(err) => Err(magnus::Error::new(
-                exception::runtime_error(),
+                ruby.exception_runtime_error(),
                 format!("{err:?}"),
             )),
         }
@@ -577,8 +578,9 @@ impl RewriterOptions {
 }
 
 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))?;