selma 0.0.2-x64-mingw-ucrt → 0.0.3-x64-mingw-ucrt

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '069c28d99a1880e6da8883eb8cdd70d0fccf57852e851f1c2177b42716f89cae'
-  data.tar.gz: c1df86b712e79b91986e6b5100b0a4138f265d8561bf222695e38e7849f9d19e
+  metadata.gz: c778a1189fea09803ab20f414e31b02ebb9502e14b9325e7f4af235526cbba4c
+  data.tar.gz: 3985ee4a86fb0d9dfcb591675569841f59a5adf3f6ce565e839ecb8b3d5493de
 SHA512:
-  metadata.gz: d97b52b64c3b5b5410167849fb04e8dfb299cdc538814d04d3ad5d6ae7d530f3512ab2da3a857cb1af0cdba522f8cc09f02fd4c7056a6da4c00578e0e1b03e07
-  data.tar.gz: cfd8c02c520bff0980a201b9f60465ce756fba6eb813cd59b3908beabad47c6ddf2f893e6d7204afe650b7c6e125ddd11b29a8a0bdc67dae6262f7429a312c99
+  metadata.gz: 1809c68d71d5b945fa757ec3b9aab66e935b44106be7e6e4c177822c23cda06fa9e29d05a0c03805eb6404eea5cad2ba7d34255e4f9faf06d8aff28f0902eede
+  data.tar.gz: 32cb02767c6f241970d745b62f7c6b36fc77bf1b19446b2e4170b109a6a36ed4efda7b3f6b33a5e4d7850091c23c0b0b3692c40849c735d786dd199b2c1e7824

data/ext/selma/Cargo.toml

@@ -6,8 +6,8 @@ edition = "2021"
 [dependencies]
 enum-iterator = "1.2"
 escapist = "0.0.1"
-magnus = "0.4"
-lol_html = { git = "https://github.com/cloudflare/lol-html", rev = "b09b7afbbcecb944f4bf338b0e669c430d91061e" }
+magnus = { git = "https://github.com/matsadler/magnus", rev = "23160f7229ac74c42da1b5096a65ccbc40962697" }
+lol_html = "0.3"
 
 [lib]
 name = "selma"

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

@@ -51,7 +51,7 @@ impl SelmaHTMLElement {
                 Ok(_) => Ok(value),
                 Err(err) => Err(Error::new(
                     exception::runtime_error(),
-                    format!("AttributeNameError: {}", err),
+                    format!("AttributeNameError: {err:?}"),
                 )),
             }
         } else {
@@ -81,7 +81,7 @@ impl SelmaHTMLElement {
                     Ok(_) => {}
                     Err(err) => Err(Error::new(
                         exception::runtime_error(),
-                        format!("AttributeNameError: {}", err),
+                        format!("AttributeNameError: {err:?}"),
                     ))
                     .unwrap(),
                 });
@@ -99,7 +99,7 @@ impl SelmaHTMLElement {
             .for_each(|ancestor| match array.push(RString::new(ancestor)) {
                 Ok(_) => {}
                 Err(err) => {
-                    Err(Error::new(exception::runtime_error(), format!("{}", err))).unwrap()
+                    Err(Error::new(exception::runtime_error(), format!("{err:?}"))).unwrap()
                 }
             });
 
@@ -151,18 +151,18 @@ impl SelmaHTMLElement {
 
     fn find_content_type(content_type: Symbol) -> ContentType {
         match content_type.name() {
-            Ok(name) => match (name) {
+            Ok(name) => match name {
                 Cow::Borrowed("as_text") => ContentType::Text,
                 Cow::Borrowed("as_html") => ContentType::Html,
                 _ => Err(Error::new(
                     exception::runtime_error(),
-                    format!("unknown symbol `{}`", name),
+                    format!("unknown symbol `{name:?}`"),
                 ))
                 .unwrap(),
             },
             Err(err) => Err(Error::new(
                 exception::runtime_error(),
-                format!("Could not unwrap symbol"),
+                format!("Could not unwrap symbol: {err:?}"),
             ))
             .unwrap(),
         }

data/ext/selma/src/native_ref_wrap.rs

@@ -1,4 +1,4 @@
-use std::{cell::Cell, marker::PhantomData, mem, rc::Rc};
+use std::{cell::Cell, marker::PhantomData, rc::Rc};
 
 // NOTE: My Rust isn't good enough to know what any of this does,
 // but it was taken from https://github.com/cloudflare/lol-html/blob/1a1ab2e2bf896f815fe8888ed78ccdf46d7c6b85/js-api/src/lib.rs#LL38
@@ -37,7 +37,7 @@ pub struct NativeRefWrap<R> {
 impl<R> NativeRefWrap<R> {
     pub fn wrap<I>(inner: &I) -> (Self, Anchor) {
         let wrap = NativeRefWrap {
-            inner_ptr: unsafe { mem::transmute(inner) },
+            inner_ptr: inner as *const I as *mut R,
             poisoned: Rc::new(Cell::new(false)),
         };
 
@@ -48,7 +48,7 @@ impl<R> NativeRefWrap<R> {
 
     pub fn wrap_mut<I>(inner: &mut I) -> (Self, Anchor) {
         let wrap = NativeRefWrap {
-            inner_ptr: unsafe { mem::transmute(inner) },
+            inner_ptr: inner as *mut I as *mut R,
             poisoned: Rc::new(Cell::new(false)),
         };
 

data/ext/selma/src/rewriter.rs

@@ -1,5 +1,3 @@
-use std::{borrow::Cow, cell::RefCell, rc::Rc};
-
 use lol_html::{
     doc_comments, doctype, element,
     html_content::{ContentType, Element, EndTag, TextChunk},
@@ -7,6 +5,8 @@ use lol_html::{
 };
 use magnus::{exception, function, method, scan_args, Module, Object, RArray, RModule, Value};
 
+use std::{borrow::Cow, cell::RefCell, primitive::str, rc::Rc};
+
 use crate::{
     html::{element::SelmaHTMLElement, end_tag::SelmaHTMLEndTag},
     sanitizer::SelmaSanitizer,
@@ -83,18 +83,18 @@ impl SelmaRewriter {
                         return Err(magnus::Error::new(
                             exception::no_method_error(),
                             format!(
-                                "Could not call #selector on {:?}; is this an object that defines it?",
-                                classname
+                                "Could not call #selector on {classname:?}; is this an object that defines it?",
+
                             ),
                         ));
                     }
 
                     let rb_selector: WrappedStruct<SelmaSelector> =
                         match rb_handler.funcall("selector", ()) {
-                            Err(e) => {
+                            Err(err) => {
                                 return Err(magnus::Error::new(
                                     exception::type_error(),
-                                    format!("Error instantiating selector: {}", e),
+                                    format!("Error instantiating selector: {err:?}"),
                                 ));
                             }
                             Ok(rb_selector) => rb_selector,
@@ -164,8 +164,6 @@ impl SelmaRewriter {
         let sanitized_html = match &self.0.borrow().sanitizer {
             None => html,
             Some(sanitizer) => {
-                // let first_pass_html = Self::perform_initial_sanitization(sanitizer, &html).unwrap();
-
                 // due to malicious html crafting
                 // (e.g. <<foo>script>...</script>, or <div <!-- comment -->> as in tests),
                 // we need to run sanitization several times to truly remove unwanted tags,
@@ -182,7 +180,7 @@ impl SelmaRewriter {
             Ok(rewritten_html) => Ok(String::from_utf8(rewritten_html).unwrap()),
             Err(err) => Err(magnus::Error::new(
                 exception::runtime_error(),
-                format!("{}", err),
+                format!("{err:?}"),
             )),
         }
     }
@@ -218,6 +216,7 @@ impl SelmaRewriter {
 
                         Ok(())
                     })],
+                    // TODO: allow for MemorySettings to be defined
                     ..Settings::default()
                 },
                 |c: &[u8]| first_pass_html.extend_from_slice(c),
@@ -361,7 +360,7 @@ impl SelmaRewriter {
                 Err(err) => {
                     return Err(magnus::Error::new(
                         exception::runtime_error(),
-                        format!("{}", err),
+                        format!("{err:?}"),
                     ));
                 }
             }
@@ -372,7 +371,7 @@ impl SelmaRewriter {
     fn process_element_handlers(
         rb_handler: Value,
         element: &mut Element,
-        ancestors: &Vec<String>,
+        ancestors: &[String],
     ) -> Result<(), magnus::Error> {
         // if `on_end_tag` function is defined, call it
         if rb_handler.respond_to(Self::SELMA_ON_END_TAG, true).unwrap() {
@@ -393,7 +392,7 @@ impl SelmaRewriter {
             Ok(_) => Ok(()),
             Err(err) => Err(magnus::Error::new(
                 exception::runtime_error(),
-                format!("{}", err),
+                format!("{err:?}"),
             )),
         }
     }
@@ -402,11 +401,12 @@ impl SelmaRewriter {
         // prevents missing `handle_text` function
         let content = text.as_str();
 
-        // FIXME: why does this happen?
+        // seems that sometimes lol-html returns blank text / EOLs?
         if content.is_empty() {
             return Ok(());
         }
-        let rb_result = rb_handler.funcall(Self::SELMA_HANDLE_TEXT, (content,));
+
+        let rb_result = rb_handler.funcall::<_, _, String>(Self::SELMA_HANDLE_TEXT, (content,));
 
         if rb_result.is_err() {
             return Err(magnus::Error::new(
@@ -419,7 +419,7 @@ impl SelmaRewriter {
             ));
         }
 
-        let new_content: String = rb_result.unwrap();
+        let new_content = rb_result.unwrap();
         // TODO: can this be an option?
         text.replace(&new_content, ContentType::Html);
 

data/ext/selma/src/sanitizer.rs

@@ -35,7 +35,7 @@ pub struct SelmaSanitizer(std::cell::RefCell<Sanitizer>);
 
 impl SelmaSanitizer {
     const SELMA_SANITIZER_ALLOW: u8 = (1 << 0);
-    const SELMA_SANITIZER_ESCAPE_TAGFILTER: u8 = (1 << 1);
+    // const SELMA_SANITIZER_ESCAPE_TAGFILTER: u8 = (1 << 1);
     const SELMA_SANITIZER_REMOVE_CONTENTS: u8 = (1 << 2);
     const SELMA_SANITIZER_WRAP_WHITESPACE: u8 = (1 << 3);
 
@@ -229,7 +229,7 @@ impl SelmaSanitizer {
         }
     }
 
-    pub fn sanitize_attributes(&self, element: &mut Element) {
+    pub fn sanitize_attributes(&self, element: &mut Element) -> Result<(), magnus::Error> {
         let binding = self.0.borrow_mut();
         let tag = Tag::tag_from_element(element);
         let element_sanitizer = Self::get_element_sanitizer(&binding, &element.tag_name());
@@ -247,7 +247,7 @@ impl SelmaSanitizer {
             // encountered, remove the entire element to be safe.
             if attr_name.starts_with("<!--") {
                 Self::force_remove_element(self, element);
-                return;
+                return Ok(());
             }
 
             // first, trim leading spaces and unescape any encodings
@@ -268,7 +268,15 @@ impl SelmaSanitizer {
                 // since output is always UTF-8.
                 if Tag::is_meta(tag) {
                     if attr_name == "charset" && unescaped_attr_val != "utf-8" {
-                        element.set_attribute(attr_name, "utf-8");
+                        match element.set_attribute(attr_name, "utf-8") {
+                            Ok(_) => {}
+                            Err(_) => {
+                                return Err(magnus::Error::new(
+                                    exception::runtime_error(),
+                                    format!("Unable to change {attr_name:?}"),
+                                ));
+                            }
+                        }
                     }
                 } else if !unescaped_attr_val.is_empty() {
                     let mut buf = String::new();
@@ -287,14 +295,16 @@ impl SelmaSanitizer {
 
         let required = &element_sanitizer.required_attrs;
         if required.contains(&"*".to_string()) {
-            return;
+            return Ok(());
         }
         for attr in element.attributes().iter() {
             let attr_name = &attr.name();
             if required.contains(attr_name) {
-                return;
+                return Ok(());
             }
         }
+
+        Ok(())
     }
 
     fn should_keep_attribute(
@@ -423,7 +433,7 @@ impl SelmaSanitizer {
             Ok(_) => Ok(true),
             Err(err) => Err(Error::new(
                 exception::runtime_error(),
-                format!("AttributeNameError: {}", err),
+                format!("AttributeNameError: {err:?}"),
             )),
         }
     }

data/ext/selma/src/selector.rs

@@ -27,7 +27,7 @@ impl SelmaSelector {
             if css.parse::<lol_html::Selector>().is_err() {
                 return Err(Error::new(
                     exception::arg_error(),
-                    format!("Could not parse `match_element` (`{}`) as valid CSS", css),
+                    format!("Could not parse `match_element` (`{css:?}`) as valid CSS"),
                 ));
             }
         }
@@ -37,10 +37,7 @@ impl SelmaSelector {
             if css.parse::<lol_html::Selector>().is_err() {
                 return Err(Error::new(
                     exception::arg_error(),
-                    format!(
-                        "Could not parse `match_text_within` (`{}`) as valid CSS",
-                        css
-                    ),
+                    format!("Could not parse `match_text_within` (`{css:?}`) as valid CSS",),
                 ));
             }
         }

data/lib/selma/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: selma
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
 platform: x64-mingw-ucrt
 authors:
 - Garen J. Torikian
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-12-21 00:00:00.000000000 Z
+date: 2022-12-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rb_sys