selma 0.0.7-x86_64-linux → 0.1.0-x86_64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bbd21b1ab2dfc59fc7c16475c993a497cdd025ca136270d92114bbab596602fe
-  data.tar.gz: 5a5b5884d5ed3b714ca80c8acfbfaf8b3b044054e834ae9fffaacce9946ac7a2
+  metadata.gz: 8c130b05fe7738da1df29eb9fc125f1e06a08d35d82580163de4d542710d0b83
+  data.tar.gz: 15c186ca42e6c9ffdc07427419effa373c3686cefd6d6a33a60888854f8ef3e5
 SHA512:
-  metadata.gz: 8ddc5f4256ffaa7bf8756c872a46caa139925bf4e9fee6c2cd447fe96e85276ddb7af24ae2038ed4eb9c30a21052cf09dd298ff44bad6f8d36c6f6a88690164e
-  data.tar.gz: e3eb10cc9b5db8eb9a1a11e2a8bb3eb92338d627d351068945ffd1bfce9d08960946288ae6513df8f9b7ee74271583b38ba67d4761ecce7dda664c1ae2eeef1b
+  metadata.gz: d58e7be164d0f66c3a06e94c0243d7f66089818365f6f40e781f211c66aa36345920265ad21be764070d45c468ad0cd2235748da97250c5737e0b95e77bff2fb
+  data.tar.gz: cdca69f98b98fc71c6b564adc410993af74d197464bee25ecc21ff7bbe9274c67542354cb6093b29d4661a4f53d48dbdbe14146a49b71e5220735176894d1f54

data/README.md

@@ -29,7 +29,7 @@ Selma can perform two different actions, either independently or together:
 - Sanitize HTML, through a [Sanitize](https://github.com/rgrove/sanitize)-like allowlist syntax; and
 - Select HTML using CSS rules, and manipulate elements and text nodes along the way.
 
-It does this through two kwargsL `sanitizer` and `handlers`. The basic API for Selma looks like this:
+It does this through two kwargs: `sanitizer` and `handlers`. The basic API for Selma looks like this:
 
 ```ruby
 sanitizer_config = {

data/lib/selma/version.rb

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

metadata

@@ -1,29 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: selma
 version: !ruby/object:Gem::Version
-  version: 0.0.7
+  version: 0.1.0
 platform: x86_64-linux
 authors:
 - Garen J. Torikian
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-01-09 00:00:00.000000000 Z
+date: 2023-03-29 00:00:00.000000000 Z
 dependencies:
-- !ruby/object:Gem::Dependency
-  name: rb_sys
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.9'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.9'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -52,20 +38,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.2'
-- !ruby/object:Gem::Dependency
-  name: rake-compiler-dock
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.2'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.2'
 description: 
 email:
 - gjtorikian@gmail.com
@@ -75,20 +47,6 @@ extra_rdoc_files: []
 files:
 - LICENSE.txt
 - README.md
-- ext/selma/Cargo.toml
-- ext/selma/_util.rb
-- ext/selma/extconf.rb
-- ext/selma/src/html.rs
-- ext/selma/src/html/element.rs
-- ext/selma/src/html/end_tag.rs
-- ext/selma/src/html/text_chunk.rs
-- ext/selma/src/lib.rs
-- ext/selma/src/native_ref_wrap.rs
-- ext/selma/src/rewriter.rs
-- ext/selma/src/sanitizer.rs
-- ext/selma/src/selector.rs
-- ext/selma/src/tags.rs
-- ext/selma/src/wrapped_struct.rs
 - lib/selma.rb
 - lib/selma/3.1/selma.so
 - lib/selma/3.2/selma.so
@@ -103,7 +61,6 @@ files:
 - lib/selma/sanitizer/config/restricted.rb
 - lib/selma/selector.rb
 - lib/selma/version.rb
-- selma.gemspec
 homepage: 
 licenses:
 - MIT
@@ -130,7 +87,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: 3.3.22
 requirements: []
-rubygems_version: 3.4.3
+rubygems_version: 3.4.4
 signing_key: 
 specification_version: 4
 summary: Selma selects and matches HTML nodes using CSS rules. Backed by Rust's lol_html

data/ext/selma/Cargo.toml

@@ -1,14 +0,0 @@
-[package]
-name = "selma"
-version = "1.0.0"
-edition = "2021"
-
-[dependencies]
-enum-iterator = "1.2"
-escapist = "0.0.2"
-magnus = { git = "https://github.com/matsadler/magnus", rev = "23160f7229ac74c42da1b5096a65ccbc40962697" }
-lol_html = "0.3"
-
-[lib]
-name = "selma"
-crate-type = ["cdylib"]

data/ext/selma/_util.rb

@@ -1,102 +0,0 @@
-# frozen_string_literal: true
-
-RUBY_MAJOR, RUBY_MINOR = RUBY_VERSION.split(".").collect(&:to_i)
-
-PACKAGE_ROOT_DIR = File.expand_path(File.join(File.dirname(__FILE__), "..", ".."))
-PACKAGE_EXT_DIR = File.join(PACKAGE_ROOT_DIR, "ext", "selma")
-
-OS = case os = RbConfig::CONFIG["host_os"].downcase
-when /linux/
-  # The official ruby-alpine Docker containers pre-build Ruby. As a result,
-  # Ruby doesn't know that it's on a musl-based platform. `ldd` is the
-  # a more reliable way to detect musl.
-  # See https://github.com/skylightio/skylight-ruby/issues/92
-  if ENV["SKYLIGHT_MUSL"] || %x(ldd --version 2>&1).include?("musl")
-    "linux-musl"
-  else
-    "linux"
-  end
-when /darwin/
-  "darwin"
-when /freebsd/
-  "freebsd"
-when /netbsd/
-  "netbsd"
-when /openbsd/
-  "openbsd"
-when /sunos|solaris/
-  "solaris"
-when /mingw|mswin/
-  "windows"
-else
-  os
-end
-
-# Normalize the platform CPU
-ARCH = case cpu = RbConfig::CONFIG["host_cpu"].downcase
-when /amd64|x86_64|x64/
-  "x86_64"
-when /i?86|x86|i86pc/
-  "x86"
-when /ppc|powerpc/
-  "powerpc"
-when /^aarch/
-  "aarch"
-when /^arm/
-  "arm"
-else
-  cpu
-end
-
-def windows?
-  OS == "windows"
-end
-
-def solaris?
-  OS == solaries
-end
-
-def darwin?
-  OS == "darwin"
-end
-
-def macos?
-  darwin? || OS == "macos"
-end
-
-def openbsd?
-  OS == "openbsd"
-end
-
-def aix?
-  OS == "aix"
-end
-
-def nix?
-  !(windows? || solaris? || darwin?)
-end
-
-def x86_64?
-  ARCH == "x86_64"
-end
-
-def x86?
-  ARCH == "x86"
-end
-
-def abs_path(path)
-  File.join(PACKAGE_EXT_DIR, path)
-end
-
-def find_header_or_abort(header, *paths)
-  find_header(header, *paths) || abort("#{header} was expected in `#{paths.join(", ")}`, but it is missing.")
-end
-
-def find_library_or_abort(lib, func, *paths)
-  find_library(lib, func, *paths) || abort("#{lib} was expected in `#{paths.join(", ")}`, but it is missing.")
-end
-
-def concat_flags(*args)
-  args.compact.join(" ")
-end
-

data/ext/selma/extconf.rb

@@ -1,6 +0,0 @@
-require "mkmf"
-require "rb_sys/mkmf"
-
-require_relative "_util"
-
-create_rust_makefile("selma/selma")

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;