selma 0.4.4 → 0.4.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 74ac7348cf564006d365a2d422b4966bbb7f9f2170fc72971945112f75fce9ee
-  data.tar.gz: ff4872ca7d0a50c8a153947e3682a5cab10f5969c42dc8aa546d11c05efebb40
+  metadata.gz: b249e3518d3e0785aca5411ae2b06c1edd45d8034bbc94cc3e38b93fe10ea089
+  data.tar.gz: 23a2d098c40860bddc46f1c8cf9d5b96f06adc372997d7eb68a240a7415cab1a
 SHA512:
-  metadata.gz: e3c92857028c55138b6d5a95e23f68815448a3cf1324920350eb864971002e4c1033508d61f28aa53df5174b7e14c2875714773249437e6c20e29c478c49956b
-  data.tar.gz: 0de6e5cbb614e1cd1de5bf2e111a27a646673dc3c046b29048a8e99bce79a45198a30598e46d0b8e977e19faff80ebc110e05b91b39d2f4f662a2fc0f478ce35
+  metadata.gz: 0c93fb4e4b203f1d8aaeb992b12130910309525fdfc1a38ac8fed82d6b3e591d1c3c8cbd54f0a1ae4f9d7447389bc6613ed1b4e3cd9ea503d70b1c519ea75d0c
+  data.tar.gz: dd6f76b860ed68b353834eaf4f534296a3435703f78125f6845aeb6fdca553b22cbe76c24eec02f905b63a69712562bba16735945700e11ebfd2daf3a2757160

data/Cargo.lock

@@ -303,9 +303,9 @@ dependencies = [
 
 [[package]]
 name = "magnus"
-version = "0.6.4"
+version = "0.7.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b1597ef40aa8c36be098249e82c9a20cf7199278ac1c1a1a995eeead6a184479"
+checksum = "3d87ae53030f3a22e83879e666cb94e58a7bdf31706878a0ba48752994146dab"
 dependencies = [
  "magnus-macros",
  "rb-sys",
@@ -426,9 +426,13 @@ dependencies = [
 
 [[package]]
 name = "ppv-lite86"
-version = "0.2.17"
+version = "0.2.19"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5b40af805b3121feab8a3c29f04d8ad262fa8e0561883e7653e024ae4479e6de"
+checksum = "2288c0e17cc8d342c712bb43a257a80ebffce59cdb33d5000d8348f3ec02528b"
+dependencies = [
+ "zerocopy",
+ "zerocopy-derive",
+]
 
 [[package]]
 name = "precomputed-hash"
@@ -804,6 +808,7 @@ version = "0.7.35"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1b9b4fd18abc82b8136838da5d50bae7bdea537c574d8dc1a34ed098d6c166f0"
 dependencies = [
+ "byteorder",
  "zerocopy-derive",
 ]
 

data/ext/selma/Cargo.toml

@@ -8,7 +8,7 @@ publish = false
 [dependencies]
 enum-iterator = "2.1"
 escapist = "0.0.2"
-magnus = { version = "0.6", features = ["rb-sys"] }
+magnus = { version = "0.7", features = ["rb-sys"] }
 rb-sys = { version = "*", default-features = false, features = [
     "stable-api-compiled-fallback",
 ] }

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

@@ -1,3 +1,5 @@
+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};
@@ -8,16 +10,14 @@ struct HTMLElement {
 }
 
 #[magnus::wrap(class = "Selma::HTML::Element")]
-pub struct SelmaHTMLElement(std::cell::RefCell<HTMLElement>);
+pub struct SelmaHTMLElement(RefCell<HTMLElement>);
 
 /// SAFETY: This is safe because we only access this data when the GVL is held.
 unsafe impl Send for SelmaHTMLElement {}
 
 impl SelmaHTMLElement {
-    pub fn new(element: &mut Element, ancestors: &[String]) -> Self {
-        let (ref_wrap, _anchor) = NativeRefWrap::wrap_mut(element);
-
-        Self(std::cell::RefCell::new(HTMLElement {
+    pub fn new(ref_wrap: NativeRefWrap<Element<'static, 'static>>, ancestors: &[String]) -> Self {
+        Self(RefCell::new(HTMLElement {
             element: ref_wrap,
             ancestors: ancestors.to_owned(),
         }))
@@ -26,13 +26,12 @@ impl SelmaHTMLElement {
     fn tag_name(&self) -> Result<String, Error> {
         let binding = self.0.borrow();
 
-        if let Ok(e) = binding.element.get() {
-            Ok(e.tag_name())
-        } else {
-            Err(Error::new(
+        match binding.element.get() {
+            Ok(e) => Ok(e.tag_name().to_string()),
+            Err(_) => Err(Error::new(
                 exception::runtime_error(),
                 "`tag_name` is not available",
-            ))
+            )),
         }
     }
 
@@ -229,24 +228,25 @@ impl SelmaHTMLElement {
         }
     }
 
-    fn remove_and_keep_content(&self) {
-        let mut binding = self.0.borrow_mut();
-
-        if let Ok(e) = binding.element.get_mut() {
-            e.remove_and_keep_content()
-        }
+    fn remove_and_keep_content(&self) -> Result<(), Error> {
+        self.0
+            .borrow_mut()
+            .element
+            .get_mut()
+            .unwrap()
+            .remove_and_keep_content();
+        Ok(())
     }
 
     fn is_removed(&self) -> Result<bool, Error> {
         let binding = self.0.borrow();
 
-        if let Ok(e) = binding.element.get() {
-            Ok(e.removed())
-        } else {
-            Err(Error::new(
+        match binding.element.get() {
+            Ok(e) => Ok(e.removed()),
+            Err(_) => Err(Error::new(
                 exception::runtime_error(),
                 "`is_removed` is not available",
-            ))
+            )),
         }
     }
 }

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

@@ -1,3 +1,5 @@
+use std::cell::RefCell;
+
 use crate::native_ref_wrap::NativeRefWrap;
 use lol_html::html_content::EndTag;
 use magnus::{method, Error, Module, RClass};
@@ -7,16 +9,14 @@ struct HTMLEndTag {
 }
 
 #[magnus::wrap(class = "Selma::HTML::EndTag")]
-pub struct SelmaHTMLEndTag(std::cell::RefCell<HTMLEndTag>);
+pub struct SelmaHTMLEndTag(RefCell<HTMLEndTag>);
 
 /// SAFETY: This is safe because we only access this data when the GVL is held.
 unsafe impl Send for SelmaHTMLEndTag {}
 
 impl SelmaHTMLEndTag {
-    pub fn new(end_tag: &mut EndTag) -> Self {
-        let (ref_wrap, _anchor) = NativeRefWrap::wrap(end_tag);
-
-        Self(std::cell::RefCell::new(HTMLEndTag { end_tag: ref_wrap }))
+    pub fn new(ref_wrap: NativeRefWrap<EndTag<'static>>) -> Self {
+        Self(RefCell::new(HTMLEndTag { end_tag: ref_wrap }))
     }
 
     fn tag_name(&self) -> String {

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

@@ -1,3 +1,5 @@
+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};
@@ -7,16 +9,14 @@ struct HTMLTextChunk {
 }
 
 #[magnus::wrap(class = "Selma::HTML::TextChunk")]
-pub struct SelmaHTMLTextChunk(std::cell::RefCell<HTMLTextChunk>);
+pub struct SelmaHTMLTextChunk(RefCell<HTMLTextChunk>);
 
 /// SAFETY: This is safe because we only access this data when the GVL is held.
 unsafe impl Send for SelmaHTMLTextChunk {}
 
 impl SelmaHTMLTextChunk {
-    pub fn new(text_chunk: &mut TextChunk) -> Self {
-        let (ref_wrap, _anchor) = NativeRefWrap::wrap_mut(text_chunk);
-
-        Self(std::cell::RefCell::new(HTMLTextChunk {
+    pub fn new(ref_wrap: NativeRefWrap<TextChunk<'static>>) -> Self {
+        Self(RefCell::new(HTMLTextChunk {
             text_chunk: ref_wrap,
         }))
     }
@@ -54,6 +54,18 @@ impl SelmaHTMLTextChunk {
         }
     }
 
+    fn is_removed(&self) -> Result<bool, Error> {
+        let binding = self.0.borrow();
+
+        match binding.text_chunk.get() {
+            Ok(tc) => Ok(tc.removed()),
+            Err(_) => Err(Error::new(
+                exception::runtime_error(),
+                "`is_removed` is not available",
+            )),
+        }
+    }
+
     fn before(&self, args: &[Value]) -> Result<(), Error> {
         let mut binding = self.0.borrow_mut();
         let text_chunk = binding.text_chunk.get_mut().unwrap();
@@ -108,6 +120,7 @@ pub fn init(c_html: RClass) -> Result<(), Error> {
     c_text_chunk.define_method("before", method!(SelmaHTMLTextChunk::before, -1))?;
     c_text_chunk.define_method("after", method!(SelmaHTMLTextChunk::after, -1))?;
     c_text_chunk.define_method("replace", method!(SelmaHTMLTextChunk::replace, -1))?;
+    c_text_chunk.define_method("removed?", method!(SelmaHTMLTextChunk::is_removed, 0))?;
 
     Ok(())
 }

data/ext/selma/src/native_ref_wrap.rs

@@ -3,7 +3,8 @@ use std::{
     sync::{Arc, Mutex},
 };
 
-// NOTE: this was taken from https://github.com/cloudflare/lol-html/blob/1a1ab2e2bf896f815fe8888ed78ccdf46d7c6b85/js-api/src/lib.rs#LL38
+// NOTE: this was inspired from
+// https://github.com/worker-tools/html-rewriter-wasm/blob/92bafdfa34c809c37036f57cb282184cada3bbc9/src/handlers.rs
 
 pub struct Anchor<'r> {
     poisoned: Arc<Mutex<bool>>,
@@ -19,27 +20,28 @@ impl<'r> Anchor<'r> {
     }
 }
 
-// impl Drop for Anchor<'_> {
-//     fn drop(&mut self) {
-//         *self.poisoned.lock().unwrap() = true;
-//     }
-// }
+impl Drop for Anchor<'_> {
+    fn drop(&mut self) {
+        *self.poisoned.lock().unwrap() = true;
+    }
+}
 
-// NOTE: wasm_bindgen doesn't allow structures with lifetimes. To workaround that
-// we create a wrapper that erases all the lifetime information from the inner reference
+// NOTE: So far as I understand it, there's no great wya to work between lol_html's lifetimes and FFI.
+// To work around that, we create a wrapper that erases all the lifetime information from the inner reference
 // and provides an anchor object that keeps track of the lifetime in the runtime.
 //
 // When anchor goes out of scope, wrapper becomes poisoned and any attempt to get inner
 // object results in exception.
+#[derive(Clone)]
 pub struct NativeRefWrap<R> {
     inner_ptr: *mut R,
     poisoned: Arc<Mutex<bool>>,
 }
 
 impl<R> NativeRefWrap<R> {
-    pub fn wrap<I>(inner: &I) -> (Self, Anchor) {
+    pub fn wrap<I>(inner: &mut I) -> (Self, Anchor) {
         let wrap = NativeRefWrap {
-            inner_ptr: inner as *const I as *mut R,
+            inner_ptr: inner as *mut I as *mut R,
             poisoned: Arc::new(Mutex::new(false)),
         };
 
@@ -48,15 +50,16 @@ impl<R> NativeRefWrap<R> {
         (wrap, anchor)
     }
 
-    pub fn wrap_mut<I>(inner: &mut I) -> (Self, Anchor) {
-        let wrap = NativeRefWrap {
-            inner_ptr: inner as *mut I as *mut R,
-            poisoned: Arc::new(Mutex::new(false)),
-        };
-
-        let anchor = Anchor::new(Arc::clone(&wrap.poisoned));
+    fn assert_not_poisoned(&self) -> Result<(), &'static str> {
+        if self.is_poisoned() {
+            Err("The object has been freed and can't be used anymore.")
+        } else {
+            Ok(())
+        }
+    }
 
-        (wrap, anchor)
+    pub fn is_poisoned(&self) -> bool {
+        *self.poisoned.lock().unwrap()
     }
 
     pub fn get(&self) -> Result<&R, &'static str> {
@@ -70,13 +73,4 @@ impl<R> NativeRefWrap<R> {
 
         Ok(unsafe { self.inner_ptr.as_mut() }.unwrap())
     }
-
-    fn assert_not_poisoned(&self) -> Result<(), &'static str> {
-        let lock = self.poisoned.lock().unwrap();
-        if *lock {
-            Err("The object has been freed and can't be used anymore.")
-        } else {
-            Ok(())
-        }
-    }
 }

data/ext/selma/src/rewriter.rs

@@ -5,17 +5,19 @@ use lol_html::{
     Settings,
 };
 use magnus::{
-    exception, function, method,
+    exception, function, gc, method,
     r_hash::ForEach,
     scan_args,
     typed_data::Obj,
     value::{Opaque, ReprValue},
-    Integer, IntoValue, Module, Object, RArray, RHash, RModule, Ruby, Symbol, Value,
+    DataTypeFunctions, Integer, IntoValue, Module, Object, RArray, RHash, RModule, Ruby, Symbol,
+    TypedData, Value,
 };
 
 use std::{
     borrow::Cow,
     cell::{Ref, RefCell},
+    mem,
     ops::Deref,
     primitive::str,
     rc::Rc,
@@ -23,31 +25,15 @@ use std::{
 
 use crate::{
     html::{element::SelmaHTMLElement, end_tag::SelmaHTMLEndTag, text_chunk::SelmaHTMLTextChunk},
+    native_ref_wrap::NativeRefWrap,
     sanitizer::SelmaSanitizer,
     selector::SelmaSelector,
     tags::Tag,
 };
 
-#[derive(Copy, Clone)]
-pub struct ObjectValue {
-    pub inner: Opaque<Value>,
-}
-
-impl IntoValue for ObjectValue {
-    fn into_value_with(self, _: &Ruby) -> Value {
-        Ruby::get().unwrap().get_inner(self.inner)
-    }
-}
-
-impl From<Value> for ObjectValue {
-    fn from(v: Value) -> Self {
-        Self { inner: v.into() }
-    }
-}
-
 #[derive(Clone)]
 pub struct Handler {
-    rb_handler: ObjectValue,
+    rb_handler: Opaque<Value>,
     rb_selector: Opaque<Obj<SelmaSelector>>,
     // total_element_handler_calls: usize,
     // total_elapsed_element_handlers: f64,
@@ -67,9 +53,18 @@ pub struct Rewriter {
     // total_elapsed: f64,
 }
 
-#[magnus::wrap(class = "Selma::Rewriter")]
+#[derive(TypedData)]
+#[magnus(class = "Selma::Rewriter", free_immediately, mark)]
 pub struct SelmaRewriter(std::cell::RefCell<Rewriter>);
 
+impl DataTypeFunctions for SelmaRewriter {
+    fn mark(&self, marker: &gc::Marker) {
+        self.0.borrow().handlers.iter().for_each(|handler| {
+            marker.mark(handler.rb_handler);
+        });
+    }
+}
+
 type RewriterValues = (
     Option<Option<Obj<SelmaSanitizer>>>,
     Option<RArray>,
@@ -112,9 +107,7 @@ impl SelmaRewriter {
             Some(rb_handlers) => {
                 let mut handlers: Vec<Handler> = vec![];
 
-                for h in rb_handlers.each() {
-                    let rb_handler = h.unwrap();
-
+                for rb_handler in rb_handlers.into_iter() {
                     // prevents missing #selector from ruining things
                     if !rb_handler.respond_to("selector", true).unwrap() {
                         let classname = unsafe { rb_handler.classname() };
@@ -137,7 +130,7 @@ impl SelmaRewriter {
                         Ok(rb_selector) => rb_selector,
                     };
                     let handler = Handler {
-                        rb_handler: ObjectValue::from(rb_handler),
+                        rb_handler: Opaque::from(rb_handler),
                         rb_selector: Opaque::from(rb_selector),
                         // total_element_handler_calls: 0,
                         // total_elapsed_element_handlers: 0.0,
@@ -296,6 +289,7 @@ impl SelmaRewriter {
                     if el.removed() {
                         return Ok(());
                     }
+                    // if it was removed, there are no attributes to sanitize
                     match sanitizer.sanitize_attributes(el) {
                         Ok(_) => Ok(()),
                         Err(err) => Err(err.to_string().into()),
@@ -390,7 +384,7 @@ impl SelmaRewriter {
                     selector.match_element().unwrap(),
                     move |el| {
                         match Self::process_element_handlers(
-                            handler.rb_handler,
+                            handler,
                             el,
                             &closure_element_stack.borrow(),
                         ) {
@@ -421,7 +415,7 @@ impl SelmaRewriter {
                             }
                         }
 
-                        match Self::process_text_handlers(handler.rb_handler, text) {
+                        match Self::process_text_handlers(handler, text) {
                             Ok(_) => Ok(()),
                             Err(err) => Err(err.to_string().into()),
                         }
@@ -493,11 +487,11 @@ impl SelmaRewriter {
     }
 
     fn process_element_handlers(
-        obj_rb_handler: ObjectValue,
+        handler: &Handler,
         element: &mut Element,
         ancestors: &[String],
     ) -> Result<(), magnus::Error> {
-        let rb_handler = Ruby::get().unwrap().get_inner(obj_rb_handler.inner);
+        let rb_handler = handler.rb_handler.into_value();
 
         // if `on_end_tag` function is defined, call it
         if rb_handler.respond_to(Self::SELMA_ON_END_TAG, true).unwrap() {
@@ -506,33 +500,42 @@ impl SelmaRewriter {
                 .end_tag_handlers()
                 .unwrap()
                 .push(Box::new(move |end_tag| {
-                    let rb_end_tag = SelmaHTMLEndTag::new(end_tag);
+                    let (ref_wrap, anchor) = NativeRefWrap::wrap(end_tag);
+
+                    let rb_end_tag = SelmaHTMLEndTag::new(ref_wrap);
 
-                    match rb_handler.funcall::<_, _, Value>(Self::SELMA_ON_END_TAG, (rb_end_tag,)) {
+                    let result =
+                        rb_handler.funcall::<_, _, Value>(Self::SELMA_ON_END_TAG, (rb_end_tag,));
+
+                    mem::drop(anchor);
+
+                    match result {
                         Ok(_) => Ok(()),
                         Err(err) => Err(err.to_string().into()),
                     }
                 }));
         }
 
-        if element.removed() {
-            return Ok(());
-        }
+        let (ref_wrap, anchor) = NativeRefWrap::wrap(element);
+        let rb_element = SelmaHTMLElement::new(ref_wrap, ancestors);
+        let result = rb_handler.funcall::<_, _, Value>(Self::SELMA_HANDLE_ELEMENT, (rb_element,));
 
-        let rb_element = SelmaHTMLElement::new(element, ancestors);
-        let rb_result =
-            rb_handler.funcall::<_, _, Value>(Self::SELMA_HANDLE_ELEMENT, (rb_element,));
-        match rb_result {
+        mem::drop(anchor);
+
+        match result {
             Ok(_) => Ok(()),
-            Err(err) => Err(err),
+            Err(err) => Err(magnus::Error::new(
+                exception::runtime_error(),
+                format!("{err:?}"),
+            )),
         }
     }
 
     fn process_text_handlers(
-        obj_rb_handler: ObjectValue,
+        handler: &Handler,
         text_chunk: &mut TextChunk,
     ) -> Result<(), magnus::Error> {
-        let rb_handler = Ruby::get().unwrap().get_inner(obj_rb_handler.inner);
+        let rb_handler = handler.rb_handler.into_value();
 
         // prevents missing `handle_text_chunk` function
         let content = text_chunk.as_str();
@@ -542,8 +545,15 @@ impl SelmaRewriter {
             return Ok(());
         }
 
-        let rb_text_chunk = SelmaHTMLTextChunk::new(text_chunk);
-        match rb_handler.funcall::<_, _, Value>(Self::SELMA_HANDLE_TEXT_CHUNK, (rb_text_chunk,)) {
+        let (ref_wrap, anchor) = NativeRefWrap::wrap(text_chunk);
+
+        let rb_text_chunk = SelmaHTMLTextChunk::new(ref_wrap);
+        let result =
+            rb_handler.funcall::<_, _, Value>(Self::SELMA_HANDLE_TEXT_CHUNK, (rb_text_chunk,));
+
+        mem::drop(anchor);
+
+        match result {
             Ok(_) => Ok(()),
             Err(err) => Err(magnus::Error::new(
                 exception::runtime_error(),

data/ext/selma/src/sanitizer.rs

@@ -200,8 +200,7 @@ impl SelmaSanitizer {
 
         let protocol_sanitizers = &mut element_sanitizer.protocol_sanitizers.borrow_mut();
 
-        for opt_allowed_protocol in allow_list.each() {
-            let allowed_protocol = opt_allowed_protocol.unwrap();
+        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()) {
                 match protocol_list {

data/lib/selma/html/element.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Selma
+  class HTML
+    class Element
+      def available?
+        !removed?
+      end
+    end
+  end
+end

data/lib/selma/html.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "html/element"
+
 module Selma
   class HTML
   end

data/lib/selma/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: selma
 version: !ruby/object:Gem::Version
-  version: 0.4.4
+  version: 0.4.5
 platform: ruby
 authors:
 - Garen J. Torikian
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2024-07-29 00:00:00.000000000 Z
+date: 2024-07-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rb_sys
@@ -80,6 +80,7 @@ files:
 - lib/selma/config.rb
 - lib/selma/extension.rb
 - lib/selma/html.rb
+- lib/selma/html/element.rb
 - lib/selma/rewriter.rb
 - lib/selma/sanitizer.rb
 - lib/selma/sanitizer/config.rb