selma 0.5.0 → 0.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5d5be18f9fcdf811681e74b5c0f502e7576929225dd871634ff7ef61b75420fb
-  data.tar.gz: 0eaec610d88093dd716e4958f6f0c41d589459204abc51b01091788846f402c9
+  metadata.gz: ed5dccbff7a289d57157e0ce627e31ed233ba316d6989ab14bfc6a9f28d241ec
+  data.tar.gz: de7de41bb7cd201f866515e3ef730491d435c90610e771dac5f928e1ca2e8688
 SHA512:
-  metadata.gz: 4a550a34761d051c04203a56fb4beb74686bf810c5c68244b308396a98f802c8a6a3d8d1d14e8097006861c1a6da8bd8fad36561f3605d87900c669fd2e8fb52
-  data.tar.gz: b260d1421ac8ce241ffe2999cd8da4037f61c1059ea3534327c0e3cf25dd5ba9b3778037505a1eea932ecf6a5b01dd0b8e27ff4a385dc165f498f056bbda8b37
+  metadata.gz: 488c6240447f302b3479a20b76e17552648399dc82a465ddd0bf3d59cb058ec095a5ceae57a4f5cfef1a3865f6e765d2fdc4a94d79796f5d654d115982c53755
+  data.tar.gz: 371014f6ed8074097f1d7fd0c0c9600bbe7a5284248c7e7fdca6db9e4a5e26c4e565e3f20fa2c61612ad3a2ef199a8e8d87dc2103dbb987aa393e53f1f95e00d

data/Cargo.lock

@@ -202,9 +202,9 @@ checksum = "0cc23270f6e1808e30a928bdc84dea0b9b4136a8bc82338574f23baf47bbd280"
 
 [[package]]
 name = "hashbrown"
-version = "0.16.1"
+version = "0.17.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "841d1cc9bed7f9236f321df977030373f4a4163ae1a7dbfe1a51a2c1a51d9100"
+checksum = "ed5909b6e89a2db4456e54cd5f673791d7eca6732202bbf2a9cc504fe2f9b84a"
 dependencies = [
  "allocator-api2",
  "equivalent",
@@ -256,9 +256,9 @@ checksum = "5e5032e24019045c762d3c0f28f5b6b8bbf38563a65908389bf7978758920897"
 
 [[package]]
 name = "lol_html"
-version = "2.8.1"
+version = "3.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6888e8653f6e49cb2924c660fc367a8beeb6239b71e117fa082153c6ea44d427"
+checksum = "2ae574a677ef0443a0bd3c291f0cab9d1e61a3ad85a1515e3cfc0bc720d5a48e"
 dependencies = [
  "bitflags",
  "cfg-if",
@@ -409,18 +409,18 @@ dependencies = [
 
 [[package]]
 name = "rb-sys"
-version = "0.9.127"
+version = "0.9.128"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d7d7c9560fe42dcffa576941394075f18a17dce89fcf718a2fa90b7dc2134d12"
+checksum = "45ca28513560e56cfb79a62b1fce363c73af170a182024ce880c77ee9429920a"
 dependencies = [
  "rb-sys-build",
 ]
 
 [[package]]
 name = "rb-sys-build"
-version = "0.9.127"
+version = "0.9.128"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f1688e8f32967ba48c89e4dfa283b57f901075f542fc7ee9c3d7c5f9091ca1d9"
+checksum = "ce04b2c55eff3a21aaa623fcc655d94373238e72cac6b3e1a3641ff31649f99a"
 dependencies = [
  "bindgen",
  "lazy_static",
@@ -483,9 +483,9 @@ dependencies = [
 
 [[package]]
 name = "selectors"
-version = "0.35.0"
+version = "0.37.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "93fdfed56cd634f04fe8b9ddf947ae3dc493483e819593d2ba17df9ad05db8b2"
+checksum = "2cfaaa6035167f0e604e42723c7650d59ee269ef220d7bbe0565602c8a0173b9"
 dependencies = [
  "bitflags",
  "cssparser",

data/README.md

@@ -161,6 +161,7 @@ The `element` argument in `handle_element` has the following methods:
 - `remove_attribute`: Remove an attribute
 - `has_attribute?`: A bool which identifies whether or not the element has an attribute
 - `attributes`: List all the attributes
+- `attribute_source_location(name)`: Returns the byte ranges of an attribute's name and value within the original input as `{ name: Range, value: Range | nil }`, or `nil` if the attribute is missing or was added/modified during the rewrite. Pure boolean attributes written without `=` (e.g. `<input disabled>`) return `nil` because lol_html does not record their position.
 - `ancestors`: List all of an element's ancestors as an array of strings
 - `before(content, as: content_type)`: Inserts `content` before the element. `content_type` is either `:text` or `:html` and determines how the content will be applied.
 - `after(content, as: content_type)`: Inserts `content` after the element. `content_type` is either `:text` or `:html` and determines how the content will be applied.

data/ext/selma/Cargo.toml

@@ -12,7 +12,7 @@ magnus = { version = "0.8", features = ["rb-sys"] }
 rb-sys = { version = "*", default-features = false, features = [
     "stable-api-compiled-fallback",
 ] }
-lol_html = "2.8"
+lol_html = "3.0"
 
 [lib]
 name = "selma"

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

@@ -114,6 +114,47 @@ impl SelmaHTMLElement {
         }
     }
 
+    fn get_attribute_source_location(&self, attr: String) -> Result<Option<RHash>, Error> {
+        let binding = self.0.borrow();
+        let ruby = Ruby::get().unwrap();
+
+        let Ok(e) = binding.element.get() else {
+            return Ok(None);
+        };
+
+        let lowered = attr.to_lowercase();
+        let attrs = e.attributes();
+        let Some(attribute) = attrs.iter().find(|a| a.name() == lowered) else {
+            return Ok(None);
+        };
+
+        let Some(name_loc) = attribute.name_source_location() else {
+            return Ok(None);
+        };
+
+        let hash = ruby.hash_new();
+        let name_range = name_loc.bytes();
+        hash.aset(
+            ruby.to_symbol("name"),
+            ruby.range_new(name_range.start, name_range.end, true)?,
+        )?;
+
+        match attribute.value_source_location() {
+            Some(loc) => {
+                let r = loc.bytes();
+                hash.aset(
+                    ruby.to_symbol("value"),
+                    ruby.range_new(r.start, r.end, true)?,
+                )?;
+            }
+            None => {
+                hash.aset(ruby.to_symbol("value"), ruby.qnil())?;
+            }
+        }
+
+        Ok(Some(hash))
+    }
+
     fn get_attributes(&self) -> Result<RHash, Error> {
         let binding = self.0.borrow();
         let ruby = Ruby::get().unwrap();
@@ -281,6 +322,10 @@ pub fn init(c_html: RClass) -> Result<(), Error> {
         method!(SelmaHTMLElement::has_attribute, 1),
     )?;
     c_element.define_method("attributes", method!(SelmaHTMLElement::get_attributes, 0))?;
+    c_element.define_method(
+        "attribute_source_location",
+        method!(SelmaHTMLElement::get_attribute_source_location, 1),
+    )?;
     c_element.define_method("ancestors", method!(SelmaHTMLElement::get_ancestors, 0))?;
 
     c_element.define_method("before", method!(SelmaHTMLElement::before, -1))?;

data/ext/selma/src/rewriter.rs

@@ -34,7 +34,11 @@ use crate::{
 #[derive(Clone)]
 pub struct Handler {
     rb_handler: Opaque<Value>,
-    rb_selector: Opaque<Obj<SelmaSelector>>,
+    // Store the selector's data by value (Rust-owned). The `#selector` method may return a
+    // freshly-built `Selma::Selector` that nothing else on the Ruby side references; keeping a
+    // `Obj`/`Opaque` handle to it would make its lifetime depend on GC (use-after-free if it is
+    // collected while the Rewriter is alive). We only ever read Rust data off it, so clone it.
+    selector: SelmaSelector,
     // total_element_handler_calls: usize,
     // total_elapsed_element_handlers: f64,
 
@@ -43,7 +47,8 @@ pub struct Handler {
 }
 
 struct RewriterOptions {
-    memory_options: MemorySettings,
+    max_allowed_memory_usage: usize,
+    preallocated_parsing_buffer_size: usize,
 }
 
 pub struct Rewriter {
@@ -126,7 +131,9 @@ impl SelmaRewriter {
                     };
                     let handler = Handler {
                         rb_handler: Opaque::from(rb_handler),
-                        rb_selector: Opaque::from(rb_selector),
+                        // clone the selector's data out of the Ruby object right away so the
+                        // Handler no longer depends on that object surviving GC (see struct docs)
+                        selector: (*rb_selector).clone(),
                         // total_element_handler_calls: 0,
                         // total_elapsed_element_handlers: 0.0,
 
@@ -162,7 +169,7 @@ impl SelmaRewriter {
                                 if let Some(max_allowed_memory_usage) = max_allowed_memory_usage {
                                     match max_allowed_memory_usage.to_u64() {
                                         Ok(max_allowed_memory_usage) => {
-                                            rewriter_options.memory_options.max_allowed_memory_usage =
+                                            rewriter_options.max_allowed_memory_usage =
                                                 max_allowed_memory_usage as usize;
                                         }
                                         Err(_e) => {
@@ -173,7 +180,7 @@ impl SelmaRewriter {
                                         }
                                     }
                                 } else {
-                                    rewriter_options.memory_options.max_allowed_memory_usage = MemorySettings::default().max_allowed_memory_usage;
+                                    rewriter_options.max_allowed_memory_usage = RewriterOptions::DEFAULT_MAX_ALLOWED_MEMORY_USAGE;
                                 }
                             }
 
@@ -183,7 +190,7 @@ impl SelmaRewriter {
                                 if let Some(preallocated_parsing_buffer_size) = preallocated_parsing_buffer_size {
                                     match preallocated_parsing_buffer_size.to_u64() {
                                         Ok(preallocated_parsing_buffer_size) => {
-                                            rewriter_options.memory_options.preallocated_parsing_buffer_size =
+                                            rewriter_options.preallocated_parsing_buffer_size =
                                                 preallocated_parsing_buffer_size as usize;
                                         }
                                         Err(_e) => {
@@ -194,7 +201,7 @@ impl SelmaRewriter {
                                         }
                                     }
                                 } else {
-                                    rewriter_options.memory_options.preallocated_parsing_buffer_size = MemorySettings::default().preallocated_parsing_buffer_size;
+                                    rewriter_options.preallocated_parsing_buffer_size = RewriterOptions::DEFAULT_PREALLOCATED_PARSING_BUFFER_SIZE;
                                 }
                             }
                         }
@@ -210,10 +217,8 @@ impl SelmaRewriter {
             }
         }
 
-        if rewriter_options
-            .memory_options
-            .preallocated_parsing_buffer_size
-            > rewriter_options.memory_options.max_allowed_memory_usage
+        if rewriter_options.preallocated_parsing_buffer_size
+            > rewriter_options.max_allowed_memory_usage
         {
             return Err(magnus::Error::new(
                 ruby.exception_arg_error(),
@@ -364,55 +369,42 @@ impl SelmaRewriter {
         handlers.iter().for_each(|handler| {
             let element_stack: Rc<RefCell<Vec<String>>> = Rc::new(RefCell::new(vec![]));
 
-            let ruby = Ruby::get().unwrap();
-
-            let selector = ruby.get_inner(handler.rb_selector);
+            let selector = &handler.selector;
 
             // TODO: test final raise by simulating errors
-            if selector.match_element().is_some() {
+            if let Some(match_element) = selector.match_element() {
                 let closure_element_stack = element_stack.clone();
 
-                element_content_handlers.push(element!(
-                    selector.match_element().unwrap(),
-                    move |el| {
-                        match Self::process_element_handlers(
-                            handler,
-                            el,
-                            &closure_element_stack.borrow(),
-                        ) {
-                            Ok(_) => Ok(()),
-                            Err(err) => Err(err.to_string().into()),
-                        }
+                element_content_handlers.push(element!(match_element, move |el| {
+                    match Self::process_element_handlers(
+                        handler,
+                        el,
+                        &closure_element_stack.borrow(),
+                    ) {
+                        Ok(_) => Ok(()),
+                        Err(err) => Err(err.to_string().into()),
                     }
-                ));
+                }));
             }
 
-            if selector.match_text_within().is_some() {
+            if let Some(match_text_within) = selector.match_text_within() {
                 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;
-                            // also checks if tag is within an ancestery of ignored tags
-                            if selector
-                                .ignore_text_within()
-                                .unwrap()
-                                .iter()
-                                .any(|t| element_stack.contains(t))
-                            {
-                                return Ok(());
-                            }
+                element_content_handlers.push(text!(match_text_within, move |text| {
+                    let element_stack = closure_element_stack.as_ref().borrow();
+                    // check if current tag is a tag we should be ignoring text within;
+                    // also checks if tag is within an ancestery of ignored tags
+                    if let Some(ignore_text_within) = selector.ignore_text_within() {
+                        if ignore_text_within.iter().any(|t| element_stack.contains(t)) {
+                            return Ok(());
                         }
+                    }
 
-                        match Self::process_text_handlers(handler, text) {
-                            Ok(_) => Ok(()),
-                            Err(err) => Err(err.to_string().into()),
-                        }
+                    match Self::process_text_handlers(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
@@ -456,15 +448,16 @@ impl SelmaRewriter {
         let binding = &self.0.borrow();
         let mut output = vec![];
         {
-            let mut rewriter = HtmlRewriter::new(
-                Settings {
-                    document_content_handlers,
-                    element_content_handlers,
-                    memory_settings: Self::get_memory_options(binding),
-                    ..Settings::default()
-                },
-                |c: &[u8]| output.extend_from_slice(c),
-            );
+            let mut settings =
+                Settings::new().with_memory_settings(Self::get_memory_options(binding));
+            for handler in document_content_handlers {
+                settings = settings.append_document_content_handler(handler);
+            }
+            for handler in element_content_handlers {
+                settings = settings.append_element_content_handler(handler);
+            }
+
+            let mut rewriter = HtmlRewriter::new(settings, |c: &[u8]| output.extend_from_slice(c));
             match rewriter.write(html) {
                 Ok(_) => {}
                 Err(err) => {
@@ -561,18 +554,23 @@ impl SelmaRewriter {
     }
 
     fn get_memory_options(binding: &Ref<Rewriter>) -> MemorySettings {
-        let options = &binding.options.memory_options;
-        MemorySettings {
-            max_allowed_memory_usage: options.max_allowed_memory_usage,
-            preallocated_parsing_buffer_size: options.preallocated_parsing_buffer_size,
-        }
+        let options = &binding.options;
+        MemorySettings::new()
+            .with_max_allowed_memory_usage(options.max_allowed_memory_usage)
+            .with_preallocated_parsing_buffer_size(options.preallocated_parsing_buffer_size)
     }
 }
 
 impl RewriterOptions {
+    // Mirrors lol_html's `MemorySettings` defaults, which are no longer exposed as
+    // public fields as of lol_html 3.0 (settings are now consuming builders).
+    const DEFAULT_MAX_ALLOWED_MEMORY_USAGE: usize = usize::MAX;
+    const DEFAULT_PREALLOCATED_PARSING_BUFFER_SIZE: usize = 1024;
+
     pub fn new() -> Self {
         Self {
-            memory_options: MemorySettings::default(),
+            max_allowed_memory_usage: Self::DEFAULT_MAX_ALLOWED_MEMORY_USAGE,
+            preallocated_parsing_buffer_size: Self::DEFAULT_PREALLOCATED_PARSING_BUFFER_SIZE,
         }
     }
 }

data/ext/selma/src/selector.rs

@@ -87,16 +87,16 @@ impl SelmaSelector {
         Ok((match_element, match_text_within, rb_ignore_text_within))
     }
 
-    pub fn match_element(&self) -> Option<String> {
-        self.match_element.clone()
+    pub fn match_element(&self) -> Option<&str> {
+        self.match_element.as_deref()
     }
 
-    pub fn match_text_within(&self) -> Option<String> {
-        self.match_text_within.clone()
+    pub fn match_text_within(&self) -> Option<&str> {
+        self.match_text_within.as_deref()
     }
 
-    pub fn ignore_text_within(&self) -> Option<Vec<String>> {
-        self.ignore_text_within.clone()
+    pub fn ignore_text_within(&self) -> Option<&[String]> {
+        self.ignore_text_within.as_deref()
     }
 }
 

data/lib/selma/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: selma
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.5.1
 platform: ruby
 authors:
 - Garen J. Torikian
@@ -112,7 +112,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '3.4'
 requirements: []
-rubygems_version: 4.0.6
+rubygems_version: 4.0.10
 specification_version: 4
 summary: Selma selects and matches HTML nodes using CSS rules. Backed by Rust's lol_html
   parser.