selma 0.4.15 → 0.5.1

data/ext/selma/Cargo.toml

@@ -12,7 +12,7 @@ magnus = { version = "0.8", features = ["rb-sys"] }
 rb-sys = { version = "*", default-features = false, features = [
     "stable-api-compiled-fallback",
 ] }
-lol_html = "2.7"
+lol_html = "3.0"
 
 [lib]
 name = "selma"

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",
             ))
         }
@@ -109,9 +114,51 @@ impl SelmaHTMLElement {
         }
     }
 
+    fn get_attribute_source_location(&self, attr: String) -> Result<Option<RHash>, Error> {
+        let binding = self.0.borrow();
+        let ruby = Ruby::get().unwrap();
+
+        let Ok(e) = binding.element.get() else {
+            return Ok(None);
+        };
+
+        let lowered = attr.to_lowercase();
+        let attrs = e.attributes();
+        let Some(attribute) = attrs.iter().find(|a| a.name() == lowered) else {
+            return Ok(None);
+        };
+
+        let Some(name_loc) = attribute.name_source_location() else {
+            return Ok(None);
+        };
+
+        let hash = ruby.hash_new();
+        let name_range = name_loc.bytes();
+        hash.aset(
+            ruby.to_symbol("name"),
+            ruby.range_new(name_range.start, name_range.end, true)?,
+        )?;
+
+        match attribute.value_source_location() {
+            Some(loc) => {
+                let r = loc.bytes();
+                hash.aset(
+                    ruby.to_symbol("value"),
+                    ruby.range_new(r.start, r.end, true)?,
+                )?;
+            }
+            None => {
+                hash.aset(ruby.to_symbol("value"), ruby.qnil())?;
+            }
+        }
+
+        Ok(Some(hash))
+    }
+
     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 +168,7 @@ impl SelmaHTMLElement {
                     Err(err) => panic!(
                         "{:?}",
                         Error::new(
-                            exception::runtime_error(),
+                            ruby.exception_runtime_error(),
                             format!("AttributeNameError: {err:?}"),
                         )
                     ),
@@ -132,17 +179,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 +292,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 +300,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))?;
@@ -273,6 +322,10 @@ pub fn init(c_html: RClass) -> Result<(), Error> {
         method!(SelmaHTMLElement::has_attribute, 1),
     )?;
     c_element.define_method("attributes", method!(SelmaHTMLElement::get_attributes, 0))?;
+    c_element.define_method(
+        "attribute_source_location",
+        method!(SelmaHTMLElement::get_attribute_source_location, 1),
+    )?;
     c_element.define_method("ancestors", method!(SelmaHTMLElement::get_ancestors, 0))?;
 
     c_element.define_method("before", method!(SelmaHTMLElement::before, -1))?;

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)),