selma 0.5.4-arm-linux-musl

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: a40a92f0ceb468717e0593dd760b4ec0958ee7b484a9c7b851c1cabed78ada78
+  data.tar.gz: 0552baf18a07b4e635fe62e6538a854e40b77b30e8480544709d33af8f7f1930
+SHA512:
+  metadata.gz: 931e86645699ec32d7c5cc9fea9abf2aa55f9b0df5190874eee6dbe24320f81fc073787f21692e996a3972113acf4ad96ec9115a103933f368661f5e8404a459
+  data.tar.gz: 65b480f8399a27550dfff138f14526de53bdba8fdae7d828c4cf8227b922f3ef1b113a1f6bf1574a60731210ddf282df3b1a72973044f0ccee0c7ba1d8d463af

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2022 Garen J. Torikian
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,339 @@
+# Selma
+
+Selma **sel**ects and **ma**tches HTML nodes using CSS rules. (It can also reject/delete nodes, but then the name isn't as cool.) It's mostly an idiomatic wrapper around Cloudflare's [lol-html](https://github.com/cloudflare/lol-html) project.
+
+![Principal Skinner asking Selma after their date: 'Isn't it nice we hate the same things?'](https://user-images.githubusercontent.com/64050/207155384-14e8bd40-780c-466f-bfff-31a8a8fc3d25.jpg)
+
+Selma's strength (aside from being backed by Rust) is that HTML content is parsed _once_ and can be manipulated multiple times.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'selma'
+```
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install selma
+
+## Usage
+
+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 kwargs: `sanitizer` and `handlers`. The basic API for Selma looks like this:
+
+```ruby
+sanitizer_config = {
+   elements: ["b", "em", "i", "strong", "u"],
+}
+sanitizer = Selma::Sanitizer.new(sanitizer_config)
+rewriter = Selma::Rewriter.new(sanitizer: sanitizer, handlers: [MatchElementRewrite.new, MatchTextRewrite.new])
+# removes any element that is not  ["b", "em", "i", "strong", "u"];
+# then calls `MatchElementRewrite` and `MatchTextRewrite` on matching HTML elements
+rewriter.rewrite(html)
+```
+
+Here's a look at each individual part.
+
+### Sanitization config
+
+Selma sanitizes by default. That is, even if the `sanitizer` kwarg is not passed in, sanitization occurs. If you truly want to disable HTML sanitization (for some reason), pass `nil`:
+
+```ruby
+Selma::Rewriter.new(sanitizer: nil) # dangerous and ill-advised
+```
+
+The configuration for the sanitization process is based on the follow key-value hash allowlist:
+
+```ruby
+# Whether or not to allow HTML comments.
+allow_comments: false,
+
+# Whether or not to allow well-formed HTML doctype declarations such as
+# "<!DOCTYPE html>" when sanitizing a document.
+allow_doctype: false,
+
+# HTML elements to allow. By default, no elements are allowed (which means
+# that all HTML will be stripped).
+elements: ["a", "b", "img", ],
+
+# HTML attributes to allow in specific elements. The key is the name of the element,
+# and the value is an array of allowed attributes. By default, no attributes
+# are allowed.
+attributes: {
+    "a" => ["href"],
+    "img" => ["src"],
+},
+
+# URL handling protocols to allow in specific attributes. By default, no
+# protocols are allowed. Use :relative in place of a protocol if you want
+# to allow relative URLs sans protocol. Set to `:all` to allow any protocol.
+protocols: {
+    "a" => { "href" => ["http", "https", "mailto", :relative] },
+    "img" => { "href" => ["http", "https"] },
+},
+
+# An Array of element names whose contents will be removed. The contents
+# of all other filtered elements will be left behind.
+remove_contents: ["iframe", "math", "noembed", "noframes", "noscript"],
+
+# Elements which, when removed, should have their contents surrounded by
+# whitespace.
+whitespace_elements: ["blockquote", "h1", "h2", "h3", "h4", "h5", "h6", ]
+```
+
+### Defining handlers
+
+The real power in Selma comes in its use of handlers. A handler is simply an object with various methods defined:
+
+- `selector`, a method which MUST return an instance of `Selma::Selector`, defining the CSS classes to match
+- `handle_element`, a method that's called on each matched element
+- `handle_text_chunk`, a method that's called on each matched text node
+
+Here's an example which rewrites the `href` attribute on `a` and the `src` attribute on `img` to be `https` rather than `http`.
+
+```ruby
+class MatchAttribute
+  SELECTOR = Selma::Selector.new(match_element: %(a[href^="http:"], img[src^="http:"]"))
+
+  def selector
+    SELECTOR
+  end
+
+  def handle_element(element)
+    if element.tag_name == "a"
+      element["href"] = rename_http(element["href"])
+    elsif element.tag_name == "img"
+      element["src"] = rename_http(element["src"])
+    end
+  end
+
+  private def rename_http(link)
+    link.sub("http", "https")
+  end
+end
+
+rewriter = Selma::Rewriter.new(handlers: [MatchAttribute.new])
+```
+
+The `Selma::Selector` object has three possible kwargs:
+
+- `match_element`: any element which matches this CSS rule will be passed on to `handle_element`
+- `match_text_within`: any text_chunk which matches this CSS rule will be passed on to `handle_text_chunk`
+- `ignore_text_within`: this is an array of element names whose text contents will be ignored
+
+Here's an example for `handle_text_chunk` which changes strings in various elements which are _not_ `pre` or `code`:
+
+```ruby
+class MatchText
+  SELECTOR = Selma::Selector.new(match_text_within: "*", ignore_text_within: ["pre", "code"])
+
+  def selector
+    SELECTOR
+  end
+
+  def handle_text_chunk(text)
+    text.replace(text.to_s, text.sub(/@.+/, "<a href=\"www.yetto.app/#{Regexp.last_match}\">"))
+  end
+end
+
+rewriter = Selma::Rewriter.new(handlers: [MatchText.new])
+```
+
+#### `element` methods
+
+The `element` argument in `handle_element` has the following methods:
+
+- `tag_name`: Gets the element's name
+- `tag_name=`: Sets the element's name
+- `self_closing?`: A bool which identifies whether or not the element is self-closing
+- `[]`: Get an attribute
+- `[]=`: Set an attribute
+- `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.
+- `prepend(content, as: content_type)`: prepends `content` to the element's inner content, i.e. inserts content right after the element's start tag. `content_type` is either `:text` or `:html` and determines how the content will be applied.
+- `append(content, as: content_type)`: appends `content` to the element's inner content, i.e. inserts content right before the element's end tag. `content_type` is either `:text` or `:html` and determines how the content will be applied.
+- `set_inner_content`: Replaces inner content of the element with `content`. `content_type` is either `:text` or `:html` and determines how the content will be applied.
+- `remove`: Removes the element and its inner content.
+- `remove_and_keep_content`: Removes the element, but keeps its content. I.e. remove start and end tags of the element.
+- `removed?`: A bool which identifies if the element has been removed or replaced with some content.
+
+#### `text_chunk` methods
+
+- `to_s` / `.content`: Gets the text node's content
+- `text_type`: identifies the type of text in the text node
+- `before(content, as: content_type)`: Inserts `content` before the text. `content_type` is either `:text` or `:html` and determines how the content will be applied.
+- `after(content, as: content_type)`: Inserts `content` after the text. `content_type` is either `:text` or `:html` and determines how the content will be applied.
+- `replace(content, as: content_type)`: Replaces the text node with `content`. `content_type` is either `:text` or `:html` and determines how the content will be applied.
+
+## Security
+
+Theoretically, a malicious user can provide a very large document for processing, which can exhaust the memory of the host machine. To set a limit on how much string content is processed at once, you can provide `memory` options:
+
+```ruby
+Selma::Rewriter.new(options: { memory: { max_allowed_memory_usage: 1_000_000 } }) # ~1MB
+```
+
+The structure of the `memory` options looks like this:
+
+```ruby
+{
+  memory: {
+    max_allowed_memory_usage: 1000,
+    preallocated_parsing_buffer_size: 100,
+  }
+}
+```
+
+Note that `preallocated_parsing_buffer_size` must always be less than `max_allowed_memory_usage`. See [the`lol_html` project documentation](https://docs.rs/lol_html/1.2.1/lol_html/struct.MemorySettings.html) to learn more about the default values.
+
+### Literal `<` in text is always escaped
+
+Whenever a sanitizer is in use, a literal `<` in text is emitted as `&lt;`. That includes `<textarea>` and `<title>`, where entities are still decoded, but not raw-text elements such as `<style>`, where they are not. This is what stops a stray `<` from fusing with the text after it into a brand new tag once the sanitizer removes whatever sat in between, e.g. `<<script></script>img src=x onerror=alert(1)>`. Your own `handle_text_chunk` handlers still receive the original text, and anything they `replace` takes precedence. An unterminated trailing token (`foo <!-- `, `foo <img src=x`) is dropped rather than passed through, since emitted verbatim it would keep parsing into whatever page the fragment is embedded in.
+
+## Benchmarks
+
+The benchmark gems live in an optional Bundler group, so install them first with `bundle config set --local with benchmark && bundle install`. When `bundle exec rake benchmark`, two different benchmarks are calculated. Here are those results on my machine.
+
+### Benchmarks for just the sanitization process
+
+Comparing Selma against popular Ruby sanitization gems:
+
+<!-- prettier-ignore-start -->
+<details>
+<pre>
+input size = 25309 bytes, 0.03 MB
+
+ruby 3.3.0 (2023-12-25 revision 5124f9ac75) [arm64-darwin23]
+Warming up --------------------------------------
+sanitize-sm 15.000 i/100ms
+selma-sm 127.000 i/100ms
+Calculating -------------------------------------
+sanitize-sm 157.643 (± 1.9%) i/s - 4.740k in 30.077172s
+selma-sm 1.278k (± 1.5%) i/s - 38.354k in 30.019722s
+
+Comparison:
+selma-sm: 1277.9 i/s
+sanitize-sm: 157.6 i/s - 8.11x slower
+
+input size = 86686 bytes, 0.09 MB
+
+ruby 3.3.0 (2023-12-25 revision 5124f9ac75) [arm64-darwin23]
+Warming up --------------------------------------
+sanitize-md 4.000 i/100ms
+selma-md 33.000 i/100ms
+Calculating -------------------------------------
+sanitize-md 40.034 (± 5.0%) i/s - 1.200k in 30.043322s
+selma-md 332.959 (± 2.1%) i/s - 9.999k in 30.045733s
+
+Comparison:
+selma-md: 333.0 i/s
+sanitize-md: 40.0 i/s - 8.32x slower
+
+input size = 7172510 bytes, 7.17 MB
+
+ruby 3.3.0 (2023-12-25 revision 5124f9ac75) [arm64-darwin23]
+Warming up --------------------------------------
+sanitize-lg 1.000 i/100ms
+selma-lg 1.000 i/100ms
+Calculating -------------------------------------
+sanitize-lg 0.141 (± 0.0%) i/s - 5.000 in 35.426127s
+selma-lg 3.963 (± 0.0%) i/s - 119.000 in 30.037386s
+
+Comparison:
+selma-lg: 4.0 i/s
+sanitize-lg: 0.1 i/s - 28.03x slower
+
+</pre>
+</details>
+<!-- prettier-ignore-end -->
+
+### Benchmarks for just the rewriting process
+
+Comparing Selma against popular Ruby HTML parsing gems:
+
+<!-- prettier-ignore-start -->
+<details>
+<pre>
+input size = 25309 bytes, 0.03 MB
+
+ruby 3.3.0 (2023-12-25 revision 5124f9ac75) [arm64-darwin23]
+Warming up --------------------------------------
+nokogiri-sm 79.000 i/100ms
+nokolexbor-sm 295.000 i/100ms
+selma-sm 237.000 i/100ms
+Calculating -------------------------------------
+nokogiri-sm 800.531 (± 2.2%) i/s - 24.016k in 30.016056s
+nokolexbor-sm 3.033k (± 3.6%) i/s - 91.155k in 30.094884s
+selma-sm 2.386k (± 1.6%) i/s - 71.574k in 30.001701s
+
+Comparison:
+nokolexbor-sm: 3033.1 i/s
+selma-sm: 2386.3 i/s - 1.27x slower
+nokogiri-sm: 800.5 i/s - 3.79x slower
+
+input size = 86686 bytes, 0.09 MB
+
+ruby 3.3.0 (2023-12-25 revision 5124f9ac75) [arm64-darwin23]
+Warming up --------------------------------------
+nokogiri-md 8.000 i/100ms
+nokolexbor-md 43.000 i/100ms
+selma-md 38.000 i/100ms
+Calculating -------------------------------------
+nokogiri-md 85.013 (± 8.2%) i/s - 2.024k in 52.257472s
+nokolexbor-md 416.074 (±11.1%) i/s - 12.341k in 30.111613s
+selma-md 361.471 (± 4.7%) i/s - 10.830k in 30.033997s
+
+Comparison:
+nokolexbor-md: 416.1 i/s
+selma-md: 361.5 i/s - same-ish: difference falls within error
+nokogiri-md: 85.0 i/s - 4.89x slower
+
+input size = 7172510 bytes, 7.17 MB
+
+ruby 3.3.0 (2023-12-25 revision 5124f9ac75) [arm64-darwin23]
+Warming up --------------------------------------
+nokogiri-lg 1.000 i/100ms
+nokolexbor-lg 1.000 i/100ms
+selma-lg 1.000 i/100ms
+Calculating -------------------------------------
+nokogiri-lg 0.805 (± 0.0%) i/s - 25.000 in 31.148730s
+nokolexbor-lg 2.194 (± 0.0%) i/s - 66.000 in 30.278108s
+selma-lg 5.541 (± 0.0%) i/s - 166.000 in 30.037197s
+
+Comparison:
+selma-lg: 5.5 i/s
+nokolexbor-lg: 2.2 i/s - 2.53x slower
+nokogiri-lg: 0.8 i/s - 6.88x slower
+
+</pre>
+</details>
+<!-- prettier-ignore-end -->
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/gjtorikian/selma. This project is a safe, welcoming space for collaboration.
+
+## Acknowledgements
+
+- https://github.com/flavorjones/ruby-c-extensions-explained#strategy-3-precompiled and [Nokogiri](https://github.com/sparklemotion/nokogiri) for hints on how to ship precompiled cross-platform gems
+- @vmg for his work at GitHub on goomba, from which some design patterns were learned
+- [sanitize](https://github.com/rgrove/sanitize) for a comprehensive configuration API and test suite
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/lib/selma/config.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Selma
+  module Config
+    OPTIONS = {
+      memory: {
+        max_allowed_memory_usage: nil,
+        preallocated_parsing_buffer_size: nil,
+      },
+    }.freeze
+  end
+end

data/lib/selma/extension.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+begin
+  # native precompiled gems package shared libraries in <gem_dir>/lib/selma/<ruby_version>
+  # load the precompiled extension file
+  ruby_version = /\d+\.\d+/.match(RUBY_VERSION)
+  require_relative "#{ruby_version}/selma"
+rescue LoadError
+  # fall back to the extension compiled upon installation.
+  # use "require" instead of "require_relative" because non-native gems will place C extension files
+  # in Gem::BasicSpecification#extension_dir after compilation (during normal installation), which
+  # is in $LOAD_PATH but not necessarily relative to this file (see nokogiri#2300)
+  require "selma/selma"
+end

data/lib/selma/html/element.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Selma
+  class HTML
+    class Element
+      def available?
+        !removed?
+      end
+    end
+  end
+end

data/lib/selma/html.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require_relative "html/element"
+
+module Selma
+  class HTML
+  end
+end

data/lib/selma/rewriter.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Selma
+  class Rewriter
+  end
+end

data/lib/selma/sanitizer/config/basic.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Selma
+  class Sanitizer
+    module Config
+      BASIC = freeze_config(
+        elements: [
+          "a",
+          "abbr",
+          "blockquote",
+          "b",
+          "br",
+          "cite",
+          "code",
+          "dd",
+          "dfn",
+          "dl",
+          "dt",
+          "em",
+          "i",
+          "kbd",
+          "li",
+          "mark",
+          "ol",
+          "p",
+          "pre",
+          "q",
+          "s",
+          "samp",
+          "small",
+          "strike",
+          "strong",
+          "sub",
+          "sup",
+          "time",
+          "u",
+          "ul",
+          "var",
+        ],
+
+        attributes: {
+          "a" => ["href"],
+          "abbr" => ["title"],
+          "blockquote" => ["cite"],
+          "dfn" => ["title"],
+          "q" => ["cite"],
+          "time" => ["datetime", "pubdate"],
+        },
+
+        protocols: {
+          "a" => { "href" => ["ftp", "http", "https", "mailto", :relative] },
+          "blockquote" => { "cite" => ["http", "https", :relative] },
+          "q" => { "cite" => ["http", "https", :relative] },
+        },
+      )
+    end
+  end
+end

data/lib/selma/sanitizer/config/default.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module Selma
+  class Sanitizer
+    module Config
+      # although there are many more protocol types, eg., ftp, xmpp, etc.,
+      # these are the only ones that are allowed by default
+      VALID_PROTOCOLS = ["http", "https", "mailto", :relative].freeze
+
+      DEFAULT = freeze_config(
+        # Whether or not to allow HTML comments. Allowing comments is strongly
+        # discouraged, since IE allows script execution within conditional
+        # comments.
+        allow_comments: false,
+
+        # Whether or not to allow well-formed HTML doctype declarations such as
+        # "<!DOCTYPE html>" when sanitizing a document.
+        allow_doctype: false,
+
+        # HTML attributes to allow in specific elements. By default, no attributes
+        # are allowed. Use the symbol :data to indicate that arbitrary HTML5
+        # data-* attributes should be allowed.
+        attributes: {},
+
+        # HTML elements to allow. By default, no elements are allowed (which means
+        # that all HTML will be stripped).
+        elements: [],
+
+        # URL handling protocols to allow in specific attributes. By default, no
+        # protocols are allowed. Use :relative in place of a protocol if you want
+        # to allow relative URLs sans protocol. Set to `:all` to allow any protocol.
+        protocols: {},
+
+        # An Array of element names whose contents will be removed. The contents
+        # of all other filtered elements will be left behind.
+        remove_contents: [
+          "iframe",
+          "math",
+          "noembed",
+          "noframes",
+          "noscript",
+          "plaintext",
+          "script",
+          "style",
+          "svg",
+          "xmp",
+        ],
+
+        # Elements which, when removed, should have their contents surrounded by
+        # whitespace.
+        whitespace_elements: [
+          "address",
+          "article",
+          "aside",
+          "blockquote",
+          "br",
+          "dd",
+          "div",
+          "dl",
+          "dt",
+          "footer",
+          "h1",
+          "h2",
+          "h3",
+          "h4",
+          "h5",
+          "h6",
+          "header",
+          "hgroup",
+          "hr",
+          "li",
+          "nav",
+          "ol",
+          "p",
+          "pre",
+          "section",
+          "ul",
+        ],
+      )
+    end
+  end
+end

data/lib/selma/sanitizer/config/relaxed.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module Selma
+  class Sanitizer
+    module Config
+      RELAXED = freeze_config(
+        elements: BASIC[:elements] + [
+          "address",
+          "article",
+          "aside",
+          "bdi",
+          "bdo",
+          "body",
+          "caption",
+          "col",
+          "colgroup",
+          "data",
+          "del",
+          "details",
+          "div",
+          "figcaption",
+          "figure",
+          "footer",
+          "h1",
+          "h2",
+          "h3",
+          "h4",
+          "h5",
+          "h6",
+          "head",
+          "header",
+          "hgroup",
+          "hr",
+          "html",
+          "img",
+          "ins",
+          "main",
+          "nav",
+          "rp",
+          "rt",
+          "ruby",
+          "section",
+          "span",
+          "style",
+          "summary",
+          "sup",
+          "table",
+          "tbody",
+          "td",
+          "tfoot",
+          "th",
+          "thead",
+          "title",
+          "tr",
+          "wbr",
+        ],
+
+        allow_doctype: true,
+
+        attributes: merge(
+          BASIC[:attributes],
+          :all => ["class", "dir", "hidden", "id", "lang", "style", "tabindex", "title", "translate"],
+          "a" => ["href", "hreflang", "name", "rel"],
+          "col" => ["span", "width"],
+          "colgroup" => ["span", "width"],
+          "data" => ["value"],
+          "del" => ["cite", "datetime"],
+          "img" => ["align", "alt", "border", "height", "src", "srcset", "width"],
+          "ins" => ["cite", "datetime"],
+          "li" => ["value"],
+          "ol" => ["reversed", "start", "type"],
+          "style" => ["media", "scoped", "type"],
+          "table" => [
+            "align",
+            "bgcolor",
+            "border",
+            "cellpadding",
+            "cellspacing",
+            "frame",
+            "rules",
+            "sortable",
+            "summary",
+            "width",
+          ],
+          "td" => ["abbr", "align", "axis", "colspan", "headers", "rowspan", "valign", "width"],
+          "th" => ["abbr", "align", "axis", "colspan", "headers", "rowspan", "scope", "sorted", "valign", "width"],
+          "ul" => ["type"],
+        ),
+
+        protocols: merge(
+          BASIC[:protocols],
+          "del" => { "cite" => ["http", "https", :relative] },
+          "img" => { "src"  => ["http", "https", :relative] },
+          "ins" => { "cite" => ["http", "https", :relative] },
+        ),
+      )
+    end
+  end
+end

data/lib/selma/sanitizer/config/restricted.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Selma
+  class Sanitizer
+    module Config
+      RESTRICTED = freeze_config(
+        elements: ["b", "em", "i", "strong", "u"],
+
+        whitespace_elements: DEFAULT[:whitespace_elements],
+      )
+    end
+  end
+end

data/lib/selma/sanitizer/config.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require "set"
+
+module Selma
+  class Sanitizer
+    module Config
+      class << self
+        # Deeply freezes and returns the given configuration Hash.
+        def freeze_config(config)
+          case config
+          when Hash
+            config.each_value { |c| freeze_config(c) }
+          when Array, Set
+            config.each { |c| freeze_config(c) }
+          end
+
+          config.freeze
+        end
+
+        # Returns a new Hash containing the result of deeply merging *other_config*
+        # into *config*. Does not modify *config* or *other_config*.
+        #
+        # This is the safest way to use a built-in config as the basis for
+        # your own custom config.
+        def merge(config, other_config = {})
+          raise ArgumentError, "config must be a Hash" unless config.is_a?(Hash)
+          raise ArgumentError, "other_config must be a Hash" unless other_config.is_a?(Hash)
+
+          merged = {}
+          keys   = Set.new(config.keys + other_config.keys).to_a
+
+          keys.each do |key|
+            oldval = config[key]
+
+            if other_config.key?(key)
+              newval = other_config[key]
+
+              merged[key] = if oldval.is_a?(Hash) && newval.is_a?(Hash)
+                oldval.empty? ? newval.dup : merge(oldval, newval)
+              elsif newval.is_a?(Array) && key != :transformers
+                Set.new(newval).to_a
+              else
+                can_dupe?(newval) ? newval.dup : newval
+              end
+            else
+              merged[key] = can_dupe?(oldval) ? oldval.dup : oldval
+            end
+          end
+
+          merged
+        end
+
+        # Returns `true` if `dup` may be safely called on _value_, `false`
+        # otherwise.
+        def can_dupe?(value)
+          !(value == true || value == false || value.nil? || value.is_a?(Method) || value.is_a?(Numeric) || value.is_a?(Symbol))
+        end
+      end
+    end
+  end
+end
+
+require "selma/sanitizer/config/basic"
+require "selma/sanitizer/config/default"
+require "selma/sanitizer/config/relaxed"
+require "selma/sanitizer/config/restricted"

data/lib/selma/sanitizer.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require "selma/sanitizer/config"
+
+module Selma
+  class Sanitizer
+  end
+end

data/lib/selma/selector.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Selma
+  class Selector
+  end
+end

data/lib/selma/version.rb

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

data/lib/selma.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+if ENV.fetch("DEBUG", false)
+  require "amazing_print"
+  require "debug"
+end
+
+require_relative "selma/extension"
+
+require_relative "selma/sanitizer"
+require_relative "selma/html"
+require_relative "selma/rewriter"
+require_relative "selma/selector"

metadata

@@ -0,0 +1,74 @@
+--- !ruby/object:Gem::Specification
+name: selma
+version: !ruby/object:Gem::Version
+  version: 0.5.4
+platform: arm-linux-musl
+authors:
+- Garen J. Torikian
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2026-10-29 00:00:00.000000000 Z
+dependencies: []
+description: 
+email:
+- gjtorikian@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- lib/selma.rb
+- lib/selma/3.2/selma.so
+- lib/selma/3.3/selma.so
+- lib/selma/3.4/selma.so
+- lib/selma/4.0/selma.so
+- lib/selma/config.rb
+- lib/selma/extension.rb
+- lib/selma/html.rb
+- lib/selma/html/element.rb
+- lib/selma/rewriter.rb
+- lib/selma/sanitizer.rb
+- lib/selma/sanitizer/config.rb
+- lib/selma/sanitizer/config/basic.rb
+- lib/selma/sanitizer/config/default.rb
+- lib/selma/sanitizer/config/relaxed.rb
+- lib/selma/sanitizer/config/restricted.rb
+- lib/selma/selector.rb
+- lib/selma/version.rb
+homepage: 
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  funding_uri: https://github.com/sponsors/gjtorikian/
+  source_code_uri: https://github.com/gjtorikian/selma
+  rubygems_mfa_required: 'true'
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.2'
+  - - "<"
+    - !ruby/object:Gem::Version
+      version: 4.1.dev
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.4'
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.3.22
+requirements: []
+rubygems_version: 3.5.23
+signing_key: 
+specification_version: 4
+summary: Selma selects and matches HTML nodes using CSS rules. Backed by Rust's lol_html
+  parser.
+test_files: []