selma 0.0.2-x86_64-darwin

data/ext/selma/src/wrapped_struct.rs

@@ -0,0 +1,92 @@
+use magnus::{error::Error, exception, gc, value::Value, RTypedData, TryConvert, TypedData};
+use std::{marker::PhantomData, ops::Deref};
+
+// NOTE: My Rust isn't good enough to know what any of this does,
+// but it was taken from https://cs.github.com/bytecodealliance/wasmtime-rb/blob/a843e4b4582a945f2c881b8bd3e2b87688ab5509/ext/src/helpers/wrapped_struct.rs#L4
+
+/// A small wrapper for `RTypedData` that keeps track of the concrete struct
+/// type, and the underlying [`Value`] for GC purposes.
+#[derive(Debug)]
+#[repr(transparent)]
+pub struct WrappedStruct<T: TypedData> {
+    inner: RTypedData,
+    phantom: PhantomData<T>,
+}
+
+impl<T: TypedData> Clone for WrappedStruct<T> {
+    fn clone(&self) -> Self {
+        Self {
+            inner: self.inner,
+            phantom: PhantomData,
+        }
+    }
+}
+impl<T: TypedData> Copy for WrappedStruct<T> {}
+
+impl<T: TypedData> WrappedStruct<T> {
+    /// Gets the underlying struct.
+    pub fn get(&self) -> Result<&T, Error> {
+        self.inner.try_convert()
+    }
+
+    /// Gets the underlying struct with a `'static` lifetime.
+    pub fn get_static(&self) -> Result<&'static T, Error> {
+        self.inner.try_convert()
+    }
+
+    /// Get the Ruby [`Value`] for this struct.
+    pub fn to_value(self) -> Value {
+        self.inner.into()
+    }
+
+    /// Marks the Ruby [`Value`] for GC.
+    pub fn mark(&self) {
+        gc::mark(&self.inner.into());
+    }
+}
+
+impl<T: TypedData> From<WrappedStruct<T>> for Value {
+    fn from(wrapped_struct: WrappedStruct<T>) -> Self {
+        wrapped_struct.to_value()
+    }
+}
+
+impl<T: TypedData> Deref for WrappedStruct<T> {
+    type Target = RTypedData;
+
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+
+impl<T: TypedData> From<T> for WrappedStruct<T> {
+    fn from(t: T) -> Self {
+        Self {
+            inner: RTypedData::wrap(t),
+            phantom: PhantomData,
+        }
+    }
+}
+
+impl<T> TryConvert for WrappedStruct<T>
+where
+    T: TypedData,
+{
+    fn try_convert(val: Value) -> Result<Self, Error> {
+        let inner = RTypedData::from_value(val).ok_or_else(|| {
+            Error::new(
+                exception::type_error(),
+                format!(
+                    "no implicit conversion of {} into {}",
+                    unsafe { val.classname() },
+                    T::class()
+                ),
+            )
+        })?;
+
+        Ok(Self {
+            inner,
+            phantom: PhantomData,
+        })
+    }
+}

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.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+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,27 @@
+# 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,42 @@
+# frozen_string_literal: true
+
+module Selma
+  class Sanitizer
+    module Config
+      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.
+        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,37 @@
+# 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", "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)
+
+          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)
+              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,85 @@
+# frozen_string_literal: true
+
+require "selma/sanitizer/config"
+
+module Selma
+  class Sanitizer
+    ALLOW = 1 << 0
+    ESCAPE_TAGFILTER = (1 << 1)
+    REMOVE_CONTENTS = (1 << 2)
+    WRAP_WHITESPACE = (1 << 3)
+
+    # initialize is in Rust, this just helps manage config setup in Ruby
+    # TODO: could this just become initialize?
+    def setup
+      allow_element(config[:elements] || [])
+
+      (config[:attributes] || {}).each do |element, attrs|
+        allow_attribute(element, attrs)
+      end
+
+      (config[:protocols] || {}).each do |element, protocols|
+        protocols.each do |attribute, pr|
+          allow_protocol(element, attribute, pr)
+        end
+      end
+
+      remove_contents(config[:remove_contents]) if config.include?(:remove_contents)
+
+      wrap_with_whitespace(config[:whitespace_elements]) if config.include?(:whitespace_elements)
+
+      set_escape_tagfilter(config.fetch(:escape_tagfilter, true))
+      set_allow_comments(config.fetch(:allow_comments, false))
+      set_allow_doctype(config.fetch(:allow_doctype, true))
+    end
+
+    def elements
+      config[:elements]
+    end
+
+    def allow_element(elements)
+      elements.flatten.each { |e| set_flag(e, ALLOW, true) }
+    end
+
+    def disallow_element(elements)
+      elements.flatten.each { |e| set_flag(e, ALLOW, false) }
+    end
+
+    def allow_attribute(element, attrs)
+      attrs.flatten.each { |attr| set_allowed_attribute(element, attr, true) }
+    end
+
+    def require_any_attributes(element, attrs)
+      if attr.empty?
+        set_required_attribute(element, "*", true)
+      else
+        attrs.flatten.each { |attr| set_required_attribute(element, attr, true) }
+      end
+    end
+
+    def disallow_attribute(element, attrs)
+      attrs.flatten.each { |attr| set_allowed_attribute(element, attr, false) }
+    end
+
+    def allow_class(element, *klass)
+      klass.flatten.each { |k| set_allowed_class(element, k, true) }
+    end
+
+    def allow_protocol(element, attr, protos)
+      protos = [protos] unless protos.is_a?(Array)
+      set_allowed_protocols(element, attr, protos)
+    end
+
+    def remove_contents(elements)
+      if elements.is_a?(TrueClass) || elements.is_a?(FalseClass)
+        set_all_flags(REMOVE_CONTENTS, elements)
+      else
+        elements.flatten.each { |e| set_flag(e, REMOVE_CONTENTS, true) }
+      end
+    end
+
+    def wrap_with_whitespace(elements)
+      elements.flatten.each { |e| set_flag(e, WRAP_WHITESPACE, true) }
+    end
+  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.0.2"
+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"

data/selma.gemspec

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+lib = File.expand_path("lib", __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "selma/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "selma"
+  spec.version       = Selma::VERSION
+  spec.authors       = ["Garen J. Torikian"]
+  spec.email         = ["gjtorikian@gmail.com"]
+
+  spec.summary       = "Selma selects and matches HTML nodes using CSS rules. Backed by Rust's lol_html parser."
+  spec.license       = "MIT"
+
+  spec.required_ruby_version = "~> 3.1"
+  # https://github.com/rubygems/rubygems/pull/5852#issuecomment-1231118509
+  spec.required_rubygems_version = ">= 3.3.22"
+
+  spec.files = ["LICENSE.txt", "README.md", "selma.gemspec"]
+  spec.files += Dir.glob("lib/**/*.rb")
+  spec.files += Dir.glob("ext/**/*.{rs,toml,lock,rb}")
+  spec.bindir = "exe"
+  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+
+  spec.require_paths = ["lib"]
+  spec.extensions = ["ext/selma/Cargo.toml"]
+
+  spec.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",
+  }
+
+  spec.add_dependency("rb_sys", "~> 0.9")
+
+  spec.add_development_dependency("rake", "~> 13.0")
+  spec.add_development_dependency("rake-compiler", "~> 1.2")
+  spec.add_development_dependency("rake-compiler-dock", "~> 1.2")
+end

metadata

@@ -0,0 +1,136 @@
+--- !ruby/object:Gem::Specification
+name: selma
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+platform: x86_64-darwin
+authors:
+- Garen J. Torikian
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2022-12-21 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
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: rake-compiler
+  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'
+- !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
+executables: []
+extensions: []
+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/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.bundle
+- lib/selma/extension.rb
+- lib/selma/html.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
+- selma.gemspec
+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.1'
+  - - "<"
+    - !ruby/object:Gem::Version
+      version: 3.2.dev
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.3.22
+requirements: []
+rubygems_version: 3.3.22
+signing_key:
+specification_version: 4
+summary: Selma selects and matches HTML nodes using CSS rules. Backed by Rust's lol_html
+  parser.
+test_files: []