selma 0.0.7-x64-mingw-ucrt → 0.1.0-x64-mingw-ucrt

data/ext/selma/src/lib.rs

@@ -1,50 +0,0 @@
-extern crate core;
-
-use lol_html::html_content::ContentType;
-use magnus::{define_module, exception, scan_args, Error, Symbol, Value};
-
-pub mod html;
-pub mod native_ref_wrap;
-pub mod rewriter;
-pub mod sanitizer;
-pub mod selector;
-pub mod tags;
-pub mod wrapped_struct;
-
-#[allow(clippy::let_unit_value)]
-fn scan_text_args(args: &[Value]) -> Result<(String, ContentType), magnus::Error> {
-    let args = scan_args::scan_args(args)?;
-    let (text,): (String,) = args.required;
-    let _: () = args.optional;
-    let _: () = args.splat;
-    let _: () = args.trailing;
-    let _: () = args.block;
-
-    let kwargs = scan_args::get_kwargs::<_, (Symbol,), (), ()>(args.keywords, &["as"], &[])?;
-    let as_sym = kwargs.required.0;
-    let as_sym_str = as_sym.name().unwrap();
-    let content_type = if as_sym_str == "text" {
-        ContentType::Text
-    } else if as_sym_str == "html" {
-        ContentType::Html
-    } else {
-        return Err(Error::new(
-            exception::runtime_error(),
-            format!("unknown symbol `{as_sym_str:?}`"),
-        ));
-    };
-
-    Ok((text, content_type))
-}
-
-#[magnus::init]
-fn init() -> Result<(), Error> {
-    let m_selma = 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");
-    html::init(m_selma).expect("cannot define Selma::HTML class");
-    selector::init(m_selma).expect("cannot define Selma::Selector class");
-
-    Ok(())
-}

data/ext/selma/src/native_ref_wrap.rs

@@ -1,79 +0,0 @@
-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
-
-pub struct Anchor<'r> {
-    poisoned: Rc<Cell<bool>>,
-    lifetime: PhantomData<&'r mut ()>,
-}
-
-impl<'r> Anchor<'r> {
-    pub fn new(poisoned: Rc<Cell<bool>>) -> Self {
-        Anchor {
-            poisoned,
-            lifetime: PhantomData,
-        }
-    }
-}
-
-// impl Drop for Anchor<'_> {
-//     fn drop(&mut self) {
-//         self.poisoned.replace(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
-// 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.
-pub struct NativeRefWrap<R> {
-    inner_ptr: *mut R,
-    poisoned: Rc<Cell<bool>>,
-}
-
-impl<R> NativeRefWrap<R> {
-    pub fn wrap<I>(inner: &I) -> (Self, Anchor) {
-        let wrap = NativeRefWrap {
-            inner_ptr: inner as *const I as *mut R,
-            poisoned: Rc::new(Cell::new(false)),
-        };
-
-        let anchor = Anchor::new(Rc::clone(&wrap.poisoned));
-
-        (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: Rc::new(Cell::new(false)),
-        };
-
-        let anchor = Anchor::new(Rc::clone(&wrap.poisoned));
-
-        (wrap, anchor)
-    }
-
-    pub fn get(&self) -> Result<&R, &'static str> {
-        self.assert_not_poisoned()?;
-
-        Ok(unsafe { self.inner_ptr.as_ref() }.unwrap())
-    }
-
-    pub fn get_mut(&mut self) -> Result<&mut R, &'static str> {
-        self.assert_not_poisoned()?;
-
-        Ok(unsafe { self.inner_ptr.as_mut() }.unwrap())
-    }
-
-    fn assert_not_poisoned(&self) -> Result<(), &'static str> {
-        if self.poisoned.get() {
-            Err("The object has been freed and can't be used anymore.")
-        } else {
-            Ok(())
-        }
-    }
-}

data/ext/selma/src/rewriter.rs

@@ -1,429 +0,0 @@
-use lol_html::{
-    doc_comments, doctype, element,
-    html_content::{Element, EndTag, TextChunk},
-    text, DocumentContentHandlers, ElementContentHandlers, HtmlRewriter, Selector, Settings,
-};
-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, text_chunk::SelmaHTMLTextChunk},
-    sanitizer::SelmaSanitizer,
-    selector::SelmaSelector,
-    tags::Tag,
-    wrapped_struct::WrappedStruct,
-};
-
-#[derive(Clone, Debug)]
-pub struct Handler {
-    rb_handler: Value,
-    rb_selector: WrappedStruct<SelmaSelector>,
-
-    total_element_handler_calls: usize,
-    total_elapsed_element_handlers: f64,
-
-    total_text_handler_calls: usize,
-    total_elapsed_text_handlers: f64,
-}
-
-pub struct Rewriter {
-    sanitizer: Option<SelmaSanitizer>,
-    handlers: Vec<Handler>,
-
-    total_elapsed: f64,
-}
-
-#[magnus::wrap(class = "Selma::Rewriter")]
-pub struct SelmaRewriter(std::cell::RefCell<Rewriter>);
-
-/// SAFETY: This is safe because we only access this data when the GVL is held.
-unsafe impl Send for SelmaRewriter {}
-
-impl SelmaRewriter {
-    const SELMA_ON_END_TAG: &str = "on_end_tag";
-    const SELMA_HANDLE_ELEMENT: &str = "handle_element";
-    const SELMA_HANDLE_TEXT_CHUNK: &str = "handle_text_chunk";
-
-    /// @yard
-    /// @def new(sanitizer: Selma::Sanitizer.new(Selma::Sanitizer::Config::DEFAULT), handlers: [])
-    /// @param sanitizer [Selma::Sanitizer] The sanitizer which performs the initial cleanup
-    /// @param handlers  [Array<Selma::Selector>] The handlers to use to perform HTML rewriting
-    /// @return [Selma::Rewriter]
-    fn new(args: &[Value]) -> Result<Self, magnus::Error> {
-        let (rb_sanitizer, rb_handlers) = Self::scan_parse_args(args)?;
-
-        let sanitizer = match rb_sanitizer {
-            None => {
-                let default_sanitizer = SelmaSanitizer::new(&[])?;
-                let wrapped_sanitizer = WrappedStruct::from(default_sanitizer);
-                wrapped_sanitizer.funcall::<&str, (), Value>("setup", ())?;
-                Some(wrapped_sanitizer.get().unwrap().to_owned())
-            }
-            Some(sanitizer_value) => match sanitizer_value {
-                None => None,
-                Some(sanitizer) => {
-                    sanitizer.funcall::<&str, (), Value>("setup", ())?;
-                    Some(sanitizer.get().unwrap().to_owned())
-                }
-            },
-        };
-
-        let handlers = match rb_handlers {
-            None => vec![],
-            Some(rb_handlers) => {
-                let mut handlers: Vec<Handler> = vec![];
-
-                for h in rb_handlers.each() {
-                    let rb_handler = h.unwrap();
-
-                    // prevents missing #selector from ruining things
-                    if !rb_handler.respond_to("selector", true).unwrap() {
-                        let classname = unsafe { rb_handler.classname() };
-                        return Err(magnus::Error::new(
-                            exception::no_method_error(),
-                            format!(
-                                "Could not call #selector on {classname:?}; is this an object that defines it?",
-
-                            ),
-                        ));
-                    }
-
-                    let rb_selector: WrappedStruct<SelmaSelector> =
-                        match rb_handler.funcall("selector", ()) {
-                            Err(err) => {
-                                return Err(magnus::Error::new(
-                                    exception::type_error(),
-                                    format!("Error instantiating selector: {err:?}"),
-                                ));
-                            }
-                            Ok(rb_selector) => rb_selector,
-                        };
-                    let handler = Handler {
-                        rb_handler,
-                        rb_selector,
-                        total_element_handler_calls: 0,
-                        total_elapsed_element_handlers: 0.0,
-
-                        total_text_handler_calls: 0,
-                        total_elapsed_text_handlers: 0.0,
-                    };
-                    handlers.push(handler);
-                }
-                handlers
-            }
-        };
-
-        if sanitizer.is_none() && handlers.is_empty() {
-            return Err(magnus::Error::new(
-                exception::arg_error(),
-                "Must provide a sanitizer or a handler",
-            ));
-        }
-
-        Ok(Self(std::cell::RefCell::new(Rewriter {
-            sanitizer,
-            handlers,
-            total_elapsed: 0.0,
-        })))
-    }
-
-    #[allow(clippy::let_unit_value)]
-    fn scan_parse_args(
-        args: &[Value],
-    ) -> Result<
-        (
-            Option<Option<WrappedStruct<SelmaSanitizer>>>,
-            Option<RArray>,
-        ),
-        magnus::Error,
-    > {
-        let args = scan_args::scan_args(args)?;
-        let _: () = args.required;
-        let _: () = args.optional;
-        let _: () = args.splat;
-        let _: () = args.trailing;
-        let _: () = args.block;
-
-        let kwargs = scan_args::get_kwargs::<
-            _,
-            (),
-            (
-                Option<Option<WrappedStruct<SelmaSanitizer>>>,
-                Option<RArray>,
-            ),
-            (),
-        >(args.keywords, &[], &["sanitizer", "handlers"])?;
-        let (rb_sanitizer, rb_handlers) = kwargs.optional;
-
-        Ok((rb_sanitizer, rb_handlers))
-    }
-
-    /// Perform HTML rewrite sequence.
-    fn rewrite(&self, html: String) -> Result<String, magnus::Error> {
-        let sanitized_html = match &self.0.borrow().sanitizer {
-            None => Ok(html),
-            Some(sanitizer) => {
-                let sanitized_html = match Self::perform_sanitization(sanitizer, &html) {
-                    Ok(sanitized_html) => sanitized_html,
-                    Err(err) => return Err(err),
-                };
-
-                String::from_utf8(sanitized_html)
-            }
-        };
-        let binding = self.0.borrow_mut();
-        let handlers = &binding.handlers;
-
-        match Self::perform_handler_rewrite(self, handlers, sanitized_html.unwrap()) {
-            Ok(rewritten_html) => Ok(String::from_utf8(rewritten_html).unwrap()),
-            Err(err) => Err(err),
-        }
-    }
-
-    fn perform_sanitization(
-        sanitizer: &SelmaSanitizer,
-        html: &String,
-    ) -> Result<Vec<u8>, magnus::Error> {
-        let mut first_pass_html = vec![];
-        {
-            let mut document_content_handlers: Vec<DocumentContentHandlers> = vec![];
-            if !sanitizer.get_allow_doctype() {
-                document_content_handlers.push(doctype!(|d| {
-                    sanitizer.remove_doctype(d);
-                    Ok(())
-                }));
-            }
-            if !sanitizer.get_allow_comments() {
-                document_content_handlers.push(doc_comments!(|c| {
-                    sanitizer.remove_comment(c);
-                    Ok(())
-                }));
-            }
-            let mut rewriter = HtmlRewriter::new(
-                Settings {
-                    document_content_handlers,
-                    element_content_handlers: vec![element!("*", |el| {
-                        sanitizer.try_remove_element(el);
-                        if el.removed() {
-                            return Ok(());
-                        }
-                        match sanitizer.sanitize_attributes(el) {
-                            Ok(_) => Ok(()),
-                            Err(err) => Err(err.to_string().into()),
-                        }
-                    })],
-                    // TODO: allow for MemorySettings to be defined
-                    ..Settings::default()
-                },
-                |c: &[u8]| first_pass_html.extend_from_slice(c),
-            );
-
-            let result = rewriter.write(html.as_bytes());
-            if result.is_err() {
-                return Err(magnus::Error::new(
-                    exception::runtime_error(),
-                    format!("Failed to sanitize HTML: {}", result.unwrap_err()),
-                ));
-            }
-        }
-
-        let mut output = vec![];
-        {
-            let mut element_content_handlers: Vec<(Cow<Selector>, ElementContentHandlers)> = vec![];
-            if sanitizer.get_escape_tagfilter() {
-                element_content_handlers.push(element!(Tag::ESCAPEWORTHY_TAGS_CSS, |el| {
-                    let should_remove = sanitizer.allow_element(el);
-                    if should_remove {
-                        sanitizer.force_remove_element(el);
-                    }
-
-                    Ok(())
-                }));
-            }
-
-            let mut rewriter = HtmlRewriter::new(
-                Settings {
-                    element_content_handlers,
-                    ..Settings::default()
-                },
-                |c: &[u8]| output.extend_from_slice(c),
-            );
-
-            let result = rewriter.write(first_pass_html.as_slice());
-            if result.is_err() {
-                return Err(magnus::Error::new(
-                    exception::runtime_error(),
-                    format!("Failed to sanitize HTML: {}", result.unwrap_err()),
-                ));
-            }
-        }
-
-        Ok(output)
-    }
-
-    pub fn perform_handler_rewrite(
-        &self,
-        handlers: &[Handler],
-        html: String,
-    ) -> Result<Vec<u8>, magnus::Error> {
-        // TODO: this should ideally be done ahead of time, not on every `#rewrite` call
-        let mut element_content_handlers: Vec<(Cow<Selector>, ElementContentHandlers)> = vec![];
-
-        handlers.iter().for_each(|handler| {
-            let element_stack: Rc<RefCell<Vec<String>>> = Rc::new(RefCell::new(vec![]));
-
-            let selector = handler.rb_selector.get_static().unwrap();
-
-            // TODO: test final raise by simulating errors
-            if selector.match_element().is_some() {
-                let closure_element_stack = element_stack.clone();
-
-                element_content_handlers.push(element!(
-                    selector.match_element().unwrap(),
-                    move |el| {
-                        match Self::process_element_handlers(
-                            handler.rb_handler,
-                            el,
-                            &closure_element_stack.borrow(),
-                        ) {
-                            Ok(_) => Ok(()),
-                            Err(err) => Err(err.to_string().into()),
-                        }
-                    }
-                ));
-            }
-
-            if selector.match_text_within().is_some() {
-                let closure_element_stack = element_stack.clone();
-
-                element_content_handlers.push(text!(
-                    selector.match_text_within().unwrap(),
-                    move |text| {
-                        let element_stack = closure_element_stack.as_ref().borrow();
-                        if selector.ignore_text_within().is_some() {
-                            // check if current tag is a tag we should be ignoring text within
-                            let head_tag_name = element_stack.last().unwrap().to_string();
-                            if selector
-                                .ignore_text_within()
-                                .unwrap()
-                                .iter()
-                                .any(|f| f == &head_tag_name)
-                            {
-                                return Ok(());
-                            }
-                        }
-
-                        match Self::process_text_handlers(handler.rb_handler, text) {
-                            Ok(_) => Ok(()),
-                            Err(err) => Err(err.to_string().into()),
-                        }
-                    }
-                ));
-            }
-
-            // we need to check *every* element we iterate over, to create a stack of elements
-            element_content_handlers.push(element!("*", move |el| {
-                let tag_name = el.tag_name().to_lowercase();
-
-                // no need to track self-closing tags
-                if Tag::tag_from_tag_name(&tag_name).self_closing {
-                    return Ok(());
-                };
-
-                element_stack.as_ref().borrow_mut().push(tag_name);
-
-                let closure_element_stack = element_stack.clone();
-                el.on_end_tag(move |_end_tag: &mut EndTag| {
-                    let mut stack = closure_element_stack.as_ref().borrow_mut();
-                    stack.pop();
-                    Ok(())
-                })?;
-                Ok(())
-            }));
-        });
-
-        let mut output = vec![];
-        {
-            let mut rewriter = HtmlRewriter::new(
-                Settings {
-                    element_content_handlers,
-                    ..Settings::default()
-                },
-                |c: &[u8]| output.extend_from_slice(c),
-            );
-            match rewriter.write(html.as_bytes()) {
-                Ok(_) => {}
-                Err(err) => {
-                    return Err(magnus::Error::new(
-                        exception::runtime_error(),
-                        format!("{err:?}"),
-                    ));
-                }
-            }
-        }
-        Ok(output)
-    }
-
-    fn process_element_handlers(
-        rb_handler: Value,
-        element: &mut Element,
-        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() {
-            // TODO: error here is an "EndTagError"
-            element.on_end_tag(move |end_tag| {
-                let rb_end_tag = SelmaHTMLEndTag::new(end_tag);
-
-                match rb_handler.funcall::<_, _, Value>(Self::SELMA_ON_END_TAG, (rb_end_tag,)) {
-                    Ok(_) => Ok(()),
-                    Err(err) => Err(err.to_string().into()),
-                }
-            });
-        }
-
-        let rb_element = SelmaHTMLElement::new(element, ancestors);
-        let rb_result =
-            rb_handler.funcall::<_, _, Value>(Self::SELMA_HANDLE_ELEMENT, (rb_element,));
-        match rb_result {
-            Ok(_) => Ok(()),
-            Err(err) => Err(err),
-        }
-    }
-
-    fn process_text_handlers(
-        rb_handler: Value,
-        text_chunk: &mut TextChunk,
-    ) -> Result<(), magnus::Error> {
-        // prevents missing `handle_text_chunk` function
-        let content = text_chunk.as_str();
-
-        // seems that sometimes lol-html returns blank text / EOLs?
-        if content.is_empty() {
-            return Ok(());
-        }
-
-        let rb_text_chunk = SelmaHTMLTextChunk::new(text_chunk);
-        match rb_handler.funcall::<_, _, Value>(Self::SELMA_HANDLE_TEXT_CHUNK, (rb_text_chunk,)) {
-            Ok(_) => Ok(()),
-            Err(err) => Err(magnus::Error::new(
-                exception::runtime_error(),
-                format!("{err:?}"),
-            )),
-        }
-    }
-}
-
-pub fn init(m_selma: RModule) -> Result<(), magnus::Error> {
-    let c_rewriter = m_selma
-        .define_class("Rewriter", Default::default())
-        .expect("cannot find class Selma::Rewriter");
-
-    c_rewriter.define_singleton_method("new", function!(SelmaRewriter::new, -1))?;
-    c_rewriter
-        .define_method("rewrite", method!(SelmaRewriter::rewrite, 1))
-        .expect("cannot define method `rewrite`");
-
-    Ok(())
-}