selma 0.0.6-x86_64-linux → 0.1.0-x86_64-linux

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

@@ -1,254 +0,0 @@
-use crate::native_ref_wrap::NativeRefWrap;
-use lol_html::html_content::Element;
-use magnus::{exception, method, Error, Module, RArray, RClass, RHash, RString, Value};
-
-struct HTMLElement {
-    element: NativeRefWrap<Element<'static, 'static>>,
-    ancestors: Vec<String>,
-}
-
-#[magnus::wrap(class = "Selma::HTML::Element")]
-pub struct SelmaHTMLElement(std::cell::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 {
-            element: ref_wrap,
-            ancestors: ancestors.to_owned(),
-        }))
-    }
-
-    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(
-                exception::runtime_error(),
-                "`tag_name` is not available",
-            ))
-        }
-    }
-
-    fn set_tag_name(&self, name: String) -> Result<(), Error> {
-        let mut binding = self.0.borrow_mut();
-
-        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:?}"))),
-            }
-        } else {
-            Err(Error::new(
-                exception::runtime_error(),
-                "`set_tag_name` is not available",
-            ))
-        }
-    }
-
-    fn is_self_closing(&self) -> Result<bool, Error> {
-        let binding = self.0.borrow();
-
-        if let Ok(e) = binding.element.get() {
-            Ok(e.is_self_closing())
-        } else {
-            Err(Error::new(
-                exception::runtime_error(),
-                "`is_self_closing` is not available",
-            ))
-        }
-    }
-
-    fn has_attribute(&self, attr: String) -> Result<bool, Error> {
-        let binding = self.0.borrow();
-
-        if let Ok(e) = binding.element.get() {
-            Ok(e.has_attribute(&attr))
-        } else {
-            Err(Error::new(
-                exception::runtime_error(),
-                "`is_self_closing` is not available",
-            ))
-        }
-    }
-
-    fn get_attribute(&self, attr: String) -> Option<String> {
-        let binding = self.0.borrow();
-        let element = binding.element.get();
-        element.unwrap().get_attribute(&attr)
-    }
-
-    fn set_attribute(&self, attr: String, value: String) -> Result<String, Error> {
-        let mut binding = self.0.borrow_mut();
-        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(),
-                    format!("AttributeNameError: {err:?}"),
-                )),
-            }
-        } else {
-            Err(Error::new(
-                exception::runtime_error(),
-                "`tag_name` is not available",
-            ))
-        }
-    }
-
-    fn remove_attribute(&self, attr: String) {
-        let mut binding = self.0.borrow_mut();
-
-        if let Ok(e) = binding.element.get_mut() {
-            e.remove_attribute(&attr)
-        }
-    }
-
-    fn get_attributes(&self) -> Result<RHash, Error> {
-        let binding = self.0.borrow();
-        let hash = RHash::new();
-
-        if let Ok(e) = binding.element.get() {
-            e.attributes()
-                .iter()
-                .for_each(|attr| match hash.aset(attr.name(), attr.value()) {
-                    Ok(_) => {}
-                    Err(err) => Err(Error::new(
-                        exception::runtime_error(),
-                        format!("AttributeNameError: {err:?}"),
-                    ))
-                    .unwrap(),
-                });
-        }
-        Ok(hash)
-    }
-
-    fn get_ancestors(&self) -> Result<RArray, Error> {
-        let binding = self.0.borrow();
-        let array = RArray::new();
-
-        binding
-            .ancestors
-            .iter()
-            .for_each(|ancestor| match array.push(RString::new(ancestor)) {
-                Ok(_) => {}
-                Err(err) => {
-                    Err(Error::new(exception::runtime_error(), format!("{err:?}"))).unwrap()
-                }
-            });
-
-        Ok(array)
-    }
-
-    fn before(&self, args: &[Value]) -> Result<(), Error> {
-        let mut binding = self.0.borrow_mut();
-        let element = binding.element.get_mut().unwrap();
-
-        let (text_str, content_type) = match crate::scan_text_args(args) {
-            Ok((text_str, content_type)) => (text_str, content_type),
-            Err(err) => return Err(err),
-        };
-
-        element.before(&text_str, content_type);
-
-        Ok(())
-    }
-
-    fn after(&self, args: &[Value]) -> Result<(), Error> {
-        let mut binding = self.0.borrow_mut();
-        let element = binding.element.get_mut().unwrap();
-
-        let (text_str, content_type) = match crate::scan_text_args(args) {
-            Ok((text_str, content_type)) => (text_str, content_type),
-            Err(err) => return Err(err),
-        };
-
-        element.after(&text_str, content_type);
-
-        Ok(())
-    }
-
-    fn prepend(&self, args: &[Value]) -> Result<(), Error> {
-        let mut binding = self.0.borrow_mut();
-        let element = binding.element.get_mut().unwrap();
-
-        let (text_str, content_type) = match crate::scan_text_args(args) {
-            Ok((text_str, content_type)) => (text_str, content_type),
-            Err(err) => return Err(err),
-        };
-
-        element.prepend(&text_str, content_type);
-
-        Ok(())
-    }
-
-    fn append(&self, args: &[Value]) -> Result<(), Error> {
-        let mut binding = self.0.borrow_mut();
-        let element = binding.element.get_mut().unwrap();
-
-        let (text_str, content_type) = match crate::scan_text_args(args) {
-            Ok((text_str, content_type)) => (text_str, content_type),
-            Err(err) => return Err(err),
-        };
-
-        element.append(&text_str, content_type);
-
-        Ok(())
-    }
-
-    fn set_inner_content(&self, args: &[Value]) -> Result<(), Error> {
-        let mut binding = self.0.borrow_mut();
-        let element = binding.element.get_mut().unwrap();
-
-        let (inner_content, content_type) = match crate::scan_text_args(args) {
-            Ok((inner_content, content_type)) => (inner_content, content_type),
-            Err(err) => return Err(err),
-        };
-
-        element.set_inner_content(&inner_content, content_type);
-
-        Ok(())
-    }
-}
-
-pub fn init(c_html: RClass) -> Result<(), Error> {
-    let c_element = c_html
-        .define_class("Element", Default::default())
-        .expect("cannot find class Selma::HTML::Element");
-
-    c_element.define_method("tag_name", method!(SelmaHTMLElement::tag_name, 0))?;
-    c_element.define_method("tag_name=", method!(SelmaHTMLElement::set_tag_name, 1))?;
-    c_element.define_method(
-        "self_closing?",
-        method!(SelmaHTMLElement::is_self_closing, 0),
-    )?;
-    c_element.define_method("[]", method!(SelmaHTMLElement::get_attribute, 1))?;
-    c_element.define_method("[]=", method!(SelmaHTMLElement::set_attribute, 2))?;
-    c_element.define_method(
-        "remove_attribute",
-        method!(SelmaHTMLElement::remove_attribute, 1),
-    )?;
-    c_element.define_method(
-        "has_attribute?",
-        method!(SelmaHTMLElement::has_attribute, 1),
-    )?;
-    c_element.define_method("attributes", method!(SelmaHTMLElement::get_attributes, 0))?;
-    c_element.define_method("ancestors", method!(SelmaHTMLElement::get_ancestors, 0))?;
-
-    c_element.define_method("before", method!(SelmaHTMLElement::before, -1))?;
-    c_element.define_method("after", method!(SelmaHTMLElement::after, -1))?;
-    c_element.define_method("prepend", method!(SelmaHTMLElement::prepend, -1))?;
-    c_element.define_method("append", method!(SelmaHTMLElement::append, -1))?;
-    c_element.define_method(
-        "set_inner_content",
-        method!(SelmaHTMLElement::set_inner_content, -1),
-    )?;
-
-    Ok(())
-}

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

@@ -1,35 +0,0 @@
-use crate::native_ref_wrap::NativeRefWrap;
-use lol_html::html_content::EndTag;
-use magnus::{method, Error, Module, RClass};
-
-struct HTMLEndTag {
-    end_tag: NativeRefWrap<EndTag<'static>>,
-}
-
-#[magnus::wrap(class = "Selma::HTML::EndTag")]
-pub struct SelmaHTMLEndTag(std::cell::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 }))
-    }
-
-    fn tag_name(&self) -> String {
-        self.0.borrow().end_tag.get().unwrap().name()
-    }
-}
-
-pub fn init(c_html: RClass) -> Result<(), Error> {
-    let c_end_tag = c_html
-        .define_class("EndTag", Default::default())
-        .expect("cannot find class Selma::HTML::EndTag");
-
-    c_end_tag.define_method("tag_name", method!(SelmaHTMLEndTag::tag_name, 0))?;
-
-    Ok(())
-}

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

@@ -1,113 +0,0 @@
-use crate::native_ref_wrap::NativeRefWrap;
-use lol_html::html_content::{TextChunk, TextType};
-use magnus::{exception, method, Error, Module, RClass, Symbol, Value};
-
-struct HTMLTextChunk {
-    text_chunk: NativeRefWrap<TextChunk<'static>>,
-}
-
-#[magnus::wrap(class = "Selma::HTML::TextChunk")]
-pub struct SelmaHTMLTextChunk(std::cell::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 {
-            text_chunk: ref_wrap,
-        }))
-    }
-
-    fn to_s(&self) -> Result<String, Error> {
-        let binding = self.0.borrow();
-
-        if let Ok(tc) = binding.text_chunk.get() {
-            Ok(tc.as_str().to_string())
-        } else {
-            Err(Error::new(
-                exception::runtime_error(),
-                "`to_s` is not available",
-            ))
-        }
-    }
-
-    fn text_type(&self) -> Result<Symbol, Error> {
-        let binding = self.0.borrow();
-
-        if let Ok(tc) = binding.text_chunk.get() {
-            match tc.text_type() {
-                TextType::Data => Ok(Symbol::from("data")),
-                TextType::PlainText => Ok(Symbol::from("plain_text")),
-                TextType::RawText => Ok(Symbol::from("raw_text")),
-                TextType::ScriptData => Ok(Symbol::from("script")),
-                TextType::RCData => Ok(Symbol::from("rc_data")),
-                TextType::CDataSection => Ok(Symbol::from("cdata_section")),
-            }
-        } else {
-            Err(Error::new(
-                exception::runtime_error(),
-                "`text_type` 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();
-
-        let (text_str, content_type) = match crate::scan_text_args(args) {
-            Ok((text_str, content_type)) => (text_str, content_type),
-            Err(err) => return Err(err),
-        };
-
-        text_chunk.before(&text_str, content_type);
-
-        Ok(())
-    }
-
-    fn after(&self, args: &[Value]) -> Result<(), Error> {
-        let mut binding = self.0.borrow_mut();
-        let text_chunk = binding.text_chunk.get_mut().unwrap();
-
-        let (text_str, content_type) = match crate::scan_text_args(args) {
-            Ok((text_str, content_type)) => (text_str, content_type),
-            Err(err) => return Err(err),
-        };
-
-        text_chunk.after(&text_str, content_type);
-
-        Ok(())
-    }
-
-    fn replace(&self, args: &[Value]) -> Result<(), Error> {
-        let mut binding = self.0.borrow_mut();
-        let text_chunk = binding.text_chunk.get_mut().unwrap();
-
-        let (text_str, content_type) = match crate::scan_text_args(args) {
-            Ok((text_str, content_type)) => (text_str, content_type),
-            Err(err) => return Err(err),
-        };
-
-        text_chunk.replace(&text_str, content_type);
-
-        Ok(())
-    }
-}
-
-pub fn init(c_html: RClass) -> Result<(), Error> {
-    let c_text_chunk = c_html
-        .define_class("TextChunk", Default::default())
-        .expect("cannot find class Selma::HTML::TextChunk");
-
-    c_text_chunk.define_method("to_s", method!(SelmaHTMLTextChunk::to_s, 0))?;
-    c_text_chunk.define_method("content", method!(SelmaHTMLTextChunk::to_s, 0))?;
-    c_text_chunk.define_method("text_type", method!(SelmaHTMLTextChunk::text_type, 0))?;
-    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))?;
-
-    Ok(())
-}

data/ext/selma/src/html.rs

@@ -1,19 +0,0 @@
-use magnus::{Error, Module, RModule};
-
-#[derive(Clone, Debug)]
-#[magnus::wrap(class = "Selma::HTML")]
-pub(crate) struct SelmaHTML {}
-
-pub fn init(m_selma: RModule) -> Result<(), Error> {
-    let c_html = m_selma.define_class("HTML", Default::default()).unwrap();
-
-    element::init(c_html).expect("cannot define Selma::HTML::Element class");
-    end_tag::init(c_html).expect("cannot define Selma::HTML::EndTag class");
-    text_chunk::init(c_html).expect("cannot define Selma::HTML::TextChunk class");
-
-    Ok(())
-}
-
-pub mod element;
-pub mod end_tag;
-pub mod text_chunk;

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(())
-        }
-    }
-}