selma 0.4.11 → 0.5.0

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",),
                 ));
             }
@@ -102,8 +101,9 @@ impl SelmaSelector {
 }
 
 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.11"
+  VERSION = "0.5.0"
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: selma
 version: !ruby/object:Gem::Version
-  version: 0.4.11
+  version: 0.5.0
 platform: ruby
 authors:
 - Garen J. Torikian
 bindir: exe
 cert_chain: []
-date: 2024-12-29 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rb_sys
@@ -100,16 +100,19 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - "~>"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: '3.1'
+      version: '3.2'
+  - - "<"
+    - !ruby/object:Gem::Version
+      version: '5'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - "~>"
+  - - ">="
     - !ruby/object:Gem::Version
       version: '3.4'
 requirements: []
-rubygems_version: 3.6.2
+rubygems_version: 4.0.6
 specification_version: 4
 summary: Selma selects and matches HTML nodes using CSS rules. Backed by Rust's lol_html
   parser.