selma 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 62e8e007de6eb92bda551ab4247b57d7643b48854874dd6ba8ce3ba6eb066138
-  data.tar.gz: 4dc2e07f7cc02547797bbe57c2c87574c25bc15d42fa2c998974c006799ed4d9
+  metadata.gz: 5f579c1ac9c0e6e24d6c5919f27072940adb9e31c5a0cc4429b6338cc24f6315
+  data.tar.gz: 90b190ebde12c3a38fb682af3627d83fe3e704ad7b9bc301d70eb81da6d1c63c
 SHA512:
-  metadata.gz: f60ba708bb9274513f781b1aa90659acb3b858ff7b39de2dffbd089fa29a667c923934f6e87520d435b2ee51429469317a71312fbdce5f82d1aa718ec8cca1c7
-  data.tar.gz: 83dd64c6cc55dd26ceeb4e13ae6d239b433946ee2e54d477ac58f8fa3c483b95cda7365f1d4b5e8c79751004e5b51bd527aa31acf77a59a145f6a895f6d05234
+  metadata.gz: 4da6d3776c6c4ad04c73bdfa43e3cef4ce1ed71ada3d5653041b388c41cf4b1c77dc65671238ea28f36092d68bd4dcf3b9585ae35f7ea8f280c68a0db6b93fed
+  data.tar.gz: e29bb6f28f5fb9123946b97948aef0e0857938b4a5869fce451cba3f1fdb95af1033908418f22ad454f5feb64295db40cc8df63fb183f6a628019bbd3618547e

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: ruby
 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