activemail 1.2.2 → 2.0.0

data/lib/activemail/configuration.rb

@@ -4,10 +4,7 @@
 require 'sorbet-runtime'
 
 require_relative 'tokens'
-require_relative 'inliner/base'
-require_relative 'inliner/premailer'
-require_relative 'inliner/roadie'
-require_relative 'inliner/null'
+require_relative 'inliner'
 
 module ActiveMail
   extend T::Sig
@@ -36,17 +33,17 @@ module ActiveMail
     block.call(configuration)
   end
 
-  # Parse mode (and the Guard's same decision): a full document carries <html.
+  # <html[\s>] so a <htmlfoo> custom tag or "<html" in text never flips the parse mode.
   sig { params(html: String).returns(T::Boolean) }
   def self.full_document?(html)
-    html.match?(/<html/i)
+    html.match?(/<html[\s>]/i)
   end
 
-  # The complete SCSS variable bridge — tokens + the container_width layout knob.
   # Single source for the .scss.erb bridge (Sprockets) and tokens:export (Propshaft).
   sig { returns(String) }
   def self.scss_variables
-    "#{tokens.to_scss}$am-grid-container-width: #{configuration.container_width}px !default;\n"
+    "#{tokens.to_scss}$am-grid-container-width: #{configuration.container_width}px !default;\n" \
+      "$am-column-count: #{configuration.column_count} !default;\n"
   end
 
   # Route warnings to the app logger when present (Sentry breadcrumbs, log
@@ -67,9 +64,8 @@ module ActiveMail
 
   # Invalid bytes degrade deterministically to U+FFFD, but that silently corrupts
   # content — surface it per on_parse_error before scrubbing.
-  sig { params(html_string: String).returns(String) }
-  def self.scrub_invalid_bytes(html_string)
-    mode = configuration.on_parse_error
+  sig { params(html_string: String, mode: Symbol).returns(String) }
+  def self.scrub_invalid_bytes(html_string, mode)
     message = '[activemail] input had invalid byte sequences; scrubbed to U+FFFD'
     raise ParseError, message if mode == :raise
 
@@ -77,20 +73,25 @@ module ActiveMail
     html_string.scrub
   end
 
-  # Zero or negative dimensions blow up at transform time (Infinity ghost width).
-  # Reject non-integers rather than silently coercing ("abc"→0, 12.9→12).
+  # Rejects non-integers rather than silently coercing ("abc"→0, 12.9→12); zero or
+  # negative dimensions blow up at transform time (Infinity ghost width).
   sig { params(name: Symbol, value: T.untyped).returns(Integer) }
-  def self.assert_positive_dimension!(name, value)
-    raise ArgumentError, "#{name} must be a positive integer, got #{value.inspect}" unless value.is_a?(Integer) && value.positive?
+  def self.positive_integer!(name, value)
+    raise TypeError, "#{name} must be an Integer, got #{value.inspect} (#{value.class})" unless value.is_a?(Integer)
+    raise ArgumentError, "#{name} must be positive, got #{value}" unless value.positive?
 
     value
   end
 
-  sig { params(name: Symbol, value: T.untyped).returns(Integer) }
-  def self.positive_integer!(name, value)
-    raise TypeError, "#{name} must be an Integer, got #{value.inspect} (#{value.class})" unless value.is_a?(Integer)
+  # Author attributes are untrusted strings: base 10 only (Integer() reads "010" as
+  # octal and "0x20" as hex), nil when not a positive integer.
+  sig { params(value: T.untyped).returns(T.nilable(Integer)) }
+  def self.parse_positive_integer(value)
+    string = value.to_s.strip
+    return unless string.match?(/\A\d+\z/)
 
-    assert_positive_dimension!(name, value)
+    int = string.to_i
+    int if int.positive?
   end
 
   class Configuration
@@ -98,27 +99,9 @@ module ActiveMail
 
     ON_PARSE_ERROR_MODES = T.let(%i[ignore warn raise].freeze, T::Array[Symbol])
 
-    INLINERS = T.let(
-      { premailer: ActiveMail::Inliner::Premailer, roadie: ActiveMail::Inliner::Roadie, null: ActiveMail::Inliner::Null }.freeze,
-      T::Hash[Symbol, T.class_of(ActiveMail::Inliner::Base)]
-    )
-
-    InlinerSetting = T.type_alias { T.any(Symbol, ActiveMail::Inliner::Base, T.class_of(ActiveMail::Inliner::Base)) }
-
-    sig { returns(InlinerSetting) }
+    sig { returns(ActiveMail::Inliner::Setting) }
     attr_reader :inliner
 
-    # Lets a host already running another inliner (e.g. premailer-rails) opt out.
-    sig { returns(T::Boolean) }
-    attr_reader :register_inline_interceptor
-
-    sig { params(value: T.untyped).void }
-    def register_inline_interceptor=(value)
-      raise TypeError, 'register_inline_interceptor must be true or false' unless [true, false].include?(value)
-
-      @register_inline_interceptor = value
-    end
-
     sig { returns(Symbol) }
     attr_reader :template_engine, :on_parse_error
 
@@ -146,26 +129,27 @@ module ActiveMail
       @container_width = T.let(600, Integer)
       @components = T.let({}, ActiveMail::ComponentMap)
       @on_parse_error = T.let(:warn, Symbol)
-      @tokens = T.let(nil, T.nilable(ActiveMail::Tokens))
-      @inliner = T.let(:premailer, InlinerSetting)
-      @resolved_inliner = T.let(nil, T.nilable(ActiveMail::Inliner::Base))
-      @register_inline_interceptor = T.let(true, T::Boolean)
+      @inliner = T.let(:premailer, ActiveMail::Inliner::Setting)
       @blank_link_rel = T.let('noopener', T.nilable(String))
     end
 
+    # Shared: building the component map per render is pure overhead.
+    sig { returns(ActiveMail::Core) }
+    def core
+      @core ||= T.let(ActiveMail::Core.new(config: self), T.nilable(ActiveMail::Core))
+    end
+
     # Validates eagerly (like sibling setters): a typo fails at boot, not silently mid-delivery.
-    sig { params(value: T.any(Symbol, String, ActiveMail::Inliner::Base, T.class_of(ActiveMail::Inliner::Base))).returns(InlinerSetting) }
+    sig { params(value: T.any(String, ActiveMail::Inliner::Setting)).returns(ActiveMail::Inliner::Setting) }
     def inliner=(value)
-      resolved = value.is_a?(String) ? value.to_sym : value
-      resolve_inliner(resolved) # raises on an invalid value, eagerly
-      @resolved_inliner = nil   # a new setting invalidates the memoized instance
-      @inliner = resolved
+      setting = value.is_a?(String) ? value.to_sym : value
+      @resolved_inliner = T.let(ActiveMail::Inliner.resolve(setting), T.nilable(ActiveMail::Inliner::Base))
+      @inliner = setting
     end
 
-    # Memoized so the lifecycle is consistent (one instance reused, not re-built per call).
     sig { returns(ActiveMail::Inliner::Base) }
     def resolved_inliner
-      @resolved_inliner ||= resolve_inliner(@inliner)
+      @resolved_inliner ||= T.let(ActiveMail::Inliner.resolve(@inliner), T.nilable(ActiveMail::Inliner::Base))
     end
 
     sig { params(value: T.untyped).returns(Symbol) }
@@ -186,11 +170,15 @@ module ActiveMail
     sig { params(value: T.untyped).returns(Integer) }
     def column_count=(value)
       @column_count = ActiveMail.positive_integer!(:column_count, value)
+      invalidate_core!
+      @column_count
     end
 
     sig { params(value: T.untyped).returns(Integer) }
     def container_width=(value)
       @container_width = ActiveMail.positive_integer!(:container_width, value)
+      invalidate_core!
+      @container_width
     end
 
     sig { params(value: T.untyped).returns(T.nilable(String)) }
@@ -209,6 +197,8 @@ module ActiveMail
       normalized = value.to_hash.transform_keys(&:to_s)
       normalized.each { |tag, klass| ActiveMail::Components.validate_component!(tag, klass) }
       @components = normalized
+      invalidate_core!
+      normalized
     end
 
     sig { params(tag: T.any(String, Symbol), component_class: T.class_of(ActiveMail::Components::Base)).void }
@@ -216,18 +206,14 @@ module ActiveMail
       ActiveMail::Components.validate_component!(tag, component_class)
 
       @components = @components.merge(tag.to_s => component_class)
+      invalidate_core!
     end
 
     private
 
-    # Single source for both eager validation (in the setter) and resolution.
-    sig { params(value: InlinerSetting).returns(ActiveMail::Inliner::Base) }
-    def resolve_inliner(value)
-      return value if value.is_a?(ActiveMail::Inliner::Base)
-      return value.new if value.is_a?(Class) && value < ActiveMail::Inliner::Base
-      return T.must(INLINERS[value]).new if value.is_a?(Symbol) && INLINERS.key?(value)
-
-      raise ArgumentError, "unknown inliner #{value.inspect}, expected one of #{INLINERS.keys.inspect}, an Inliner::Base subclass, or an instance"
+    sig { void }
+    def invalidate_core!
+      @core = nil
     end
   end
 end

data/lib/activemail/errors.rb

@@ -0,0 +1,15 @@
+# typed: strict
+# frozen_string_literal: true
+
+module ActiveMail
+  class Error < StandardError; end
+
+  class ParseError < Error; end
+
+  class StylesheetNotFound < Error; end
+
+  module Inliner
+    # The adapter's original exception is preserved as Exception#cause.
+    class Error < ActiveMail::Error; end
+  end
+end

data/lib/activemail/inliner/base.rb

@@ -3,12 +3,10 @@
 
 require 'sorbet-runtime'
 
+require_relative '../errors'
+
 module ActiveMail
   module Inliner
-    # Raised when an adapter fails; the original (premailer/roadie/nokogiri)
-    # exception is preserved as Exception#cause with its backtrace intact.
-    class Error < StandardError; end
-
     # DIP seam: ActiveMail depends on this abstraction, not premailer/roadie.
     class Base
       extend T::Sig
@@ -18,12 +16,6 @@ module ActiveMail
 
       sig { abstract.params(html: String).returns(String) }
       def inline(html); end
-
-      # Lets the interceptor skip work without type-checking concrete adapters.
-      sig { returns(T::Boolean) }
-      def noop?
-        false
-      end
     end
   end
 end

data/lib/activemail/inliner/null.rb

@@ -13,11 +13,6 @@ module ActiveMail
       def inline(html)
         html
       end
-
-      sig { override.returns(T::Boolean) }
-      def noop?
-        true
-      end
     end
   end
 end

data/lib/activemail/inliner/roadie.rb

@@ -22,7 +22,7 @@ module ActiveMail
         require 'roadie'
       rescue LoadError
         # Unify on Inliner::Error (LoadError is not a StandardError, so the
-        # interceptor's rescue would otherwise miss it); the LoadError is #cause.
+        # Pipeline's rescue would otherwise miss it); the LoadError is #cause.
         raise ActiveMail::Inliner::Error, "ActiveMail::Inliner::Roadie requires the 'roadie' gem. Add it to your Gemfile."
       end
     end

data/lib/activemail/inliner.rb

@@ -0,0 +1,33 @@
+# typed: strict
+# frozen_string_literal: true
+
+require 'sorbet-runtime'
+
+require_relative 'inliner/base'
+require_relative 'inliner/premailer'
+require_relative 'inliner/roadie'
+require_relative 'inliner/null'
+
+module ActiveMail
+  module Inliner
+    extend T::Sig
+
+    ADAPTERS = T.let(
+      { premailer: Premailer, roadie: Roadie, null: Null }.freeze,
+      T::Hash[Symbol, T.class_of(Base)]
+    )
+
+    Setting = T.type_alias { T.any(Symbol, Base, T.class_of(Base)) }
+
+    sig { params(setting: Setting).returns(Base) }
+    def self.resolve(setting)
+      return setting if setting.is_a?(Base)
+      return setting.new if setting.is_a?(Class) && setting < Base
+
+      adapter = ADAPTERS[setting] if setting.is_a?(Symbol)
+      return adapter.new if adapter
+
+      raise ArgumentError, "unknown inliner #{setting.inspect}, expected one of #{ADAPTERS.keys.inspect}, an Inliner::Base subclass, or an instance"
+    end
+  end
+end

data/lib/activemail/parse_error_reporter.rb

@@ -7,19 +7,20 @@ require_relative 'libxml'
 
 module ActiveMail
   # Surfaces libxml2 recover-mode repairs that would otherwise silently change
-  # the rendered email, honoring ActiveMail.configuration.on_parse_error.
+  # the rendered email, honoring the config's on_parse_error.
   class ParseErrorReporter
     extend T::Sig
 
-    sig { params(known_tags: T::Array[String]).void }
-    def initialize(known_tags)
+    sig { params(known_tags: T::Array[String], config: ActiveMail::Configuration).void }
+    def initialize(known_tags, config)
+      @config = config
       # dup.freeze: the caller's array stays decoupled and cannot be mutated under us.
       @known_tags = T.let(known_tags.dup.freeze, T::Array[String])
     end
 
     sig { params(errors: T::Array[Nokogiri::XML::SyntaxError]).void }
     def call(errors)
-      mode = ::ActiveMail.configuration.on_parse_error
+      mode = @config.on_parse_error
       return if mode == :ignore
 
       relevant = errors.reject { |error| known_tag_error?(error) }

data/lib/activemail/pipeline.rb

@@ -0,0 +1,26 @@
+# typed: strict
+# frozen_string_literal: true
+
+require 'sorbet-runtime'
+
+module ActiveMail
+  module Pipeline
+    extend T::Sig
+
+    sig { params(html: String, config: ActiveMail::Configuration).returns(String) }
+    def self.call(html, config: ActiveMail.configuration)
+      inline(config.resolved_inliner, config.core.transpile(html))
+    end
+
+    sig { params(inliner: ActiveMail::Inliner::Base, html: String).returns(String) }
+    def self.inline(inliner, html)
+      inliner.inline(html)
+    rescue ActiveMail::Inliner::Error
+      raise
+    rescue StandardError => e
+      # A silently non-inlined mail is worse than a failed one.
+      raise ActiveMail::Inliner::Error, "[#{inliner.class}] CSS inlining failed: #{e.message}"
+    end
+    private_class_method :inline
+  end
+end

data/lib/activemail/quality/builtin_rules.rb

@@ -0,0 +1,154 @@
+# typed: strict
+# frozen_string_literal: true
+
+require 'nokogiri'
+require 'sorbet-runtime'
+
+require_relative '../libxml'
+require_relative 'preview_renderer'
+require_relative 'rule'
+
+module ActiveMail
+  module Quality
+    class BuiltinRules
+      extend T::Sig
+
+      NAMES = T.let(
+        %i[
+          max_bytes parse_error table_role img_alt lang min_full_doc_bytes translation_missing single_root
+          translation_missing_text html_part_present text_part_present text_part_plain
+        ].freeze,
+        T::Array[Symbol]
+      )
+      MARKUP_IN_TEXT = %r{<(?:table|div|span|p|br|a)[\s>/]}i
+      MISSING_TRANSLATION = /translation[ _]missing/i
+      ROOTS = T.let({ html: /<html[\s>]/i, body: /<body[\s>]/i }.freeze, T::Hash[Symbol, Regexp])
+
+      sig { params(max_bytes: Integer, min_full_doc_bytes: Integer).void }
+      def initialize(max_bytes:, min_full_doc_bytes:)
+        # A non-positive threshold would silently disable (or invert) a check.
+        @max_bytes = T.let(::ActiveMail.positive_integer!(:max_bytes, max_bytes), Integer)
+        @min_full_doc_bytes = T.let(::ActiveMail.positive_integer!(:min_full_doc_bytes, min_full_doc_bytes), Integer)
+      end
+
+      sig { returns(T::Array[Rule]) }
+      def rules
+        structure_rules + content_rules + message_rules
+      end
+
+      private
+
+      sig { returns(T::Array[Rule]) }
+      def structure_rules
+        [
+          Rule.html(:max_bytes) { |_doc, html| size_message(html) },
+          # The Core surfaces libxml2 repairs on input; the validation layer must not
+          # silently bless malformed *output* (mismatched tags, bad entities) before send.
+          Rule.html(:parse_error) { |doc, _html| parse_error_message(doc) },
+          Rule.html(:table_role) { |doc, _html| table_role_message(doc) },
+          Rule.html(:img_alt) { |doc, _html| img_alt_message(doc) }
+        ]
+      end
+
+      sig { returns(T::Array[Rule]) }
+      def content_rules
+        [
+          Rule.html(:translation_missing) { |_doc, html| translation_missing_message(html) },
+          Rule.html(:single_root) { |_doc, html| single_root_messages(html) },
+          Rule.html(:min_full_doc_bytes) { |_doc, html| min_full_doc_message(html) },
+          Rule.html(:lang) { |doc, html| lang_message(doc, html) }
+        ]
+      end
+
+      sig { returns(T::Array[Rule]) }
+      def message_rules
+        [
+          Rule.message(:translation_missing_text) { |mail| translation_missing_text_message(mail) },
+          Rule.message(:html_part_present) { |mail| html_part_present_message(mail) },
+          Rule.message(:text_part_present) { |mail| text_part_present_message(mail) },
+          Rule.message(:text_part_plain) { |mail| text_part_plain_message(mail) }
+        ]
+      end
+
+      sig { params(html: String).returns(T.nilable(String)) }
+      def size_message(html)
+        return if html.bytesize <= @max_bytes
+
+        "HTML is #{html.bytesize} bytes, exceeds #{@max_bytes} (Gmail clipping)"
+      end
+
+      sig { params(doc: Nokogiri::XML::Document).returns(T.nilable(String)) }
+      def parse_error_message(doc)
+        errors = doc.errors.reject { |e| e.code == LIBXML_UNKNOWN_TAG_CODE }
+        return if errors.empty?
+
+        "malformed HTML: #{errors.first(3).map { |e| e.message.to_s.strip }.join('; ')}"
+      end
+
+      sig { params(doc: Nokogiri::XML::Document).returns(T.nilable(String)) }
+      def table_role_message(doc)
+        offenders = doc.css('table').count { |table| table['role'] != 'presentation' }
+        %(#{offenders} <table> missing role="presentation") unless offenders.zero?
+      end
+
+      sig { params(doc: Nokogiri::XML::Document).returns(T.nilable(String)) }
+      def img_alt_message(doc)
+        offenders = doc.css('img').count { |img| !img.key?('alt') }
+        "#{offenders} <img> missing an alt attribute" unless offenders.zero?
+      end
+
+      sig { params(html: String).returns(T.nilable(String)) }
+      def translation_missing_message(html)
+        'rendered HTML contains a missing i18n translation' if html.match?(MISSING_TRANSLATION)
+      end
+
+      # Counted on the raw string: libxml2 silently merges duplicate roots.
+      sig { params(html: String).returns(T::Array[String]) }
+      def single_root_messages(html)
+        ROOTS.filter_map do |tag, pattern|
+          count = html.scan(pattern).size
+          "#{count} <#{tag}> roots, expected at most one" if count > 1
+        end
+      end
+
+      sig { params(html: String).returns(T.nilable(String)) }
+      def min_full_doc_message(html)
+        return unless ::ActiveMail.full_document?(html) && html.bytesize < @min_full_doc_bytes
+
+        "full document is only #{html.bytesize} bytes (under #{@min_full_doc_bytes})"
+      end
+
+      sig { params(doc: Nokogiri::XML::Document, html: String).returns(T.nilable(String)) }
+      def lang_message(doc, html)
+        return unless ::ActiveMail.full_document?(html)
+
+        html_tag = doc.at_css('html')
+        lang = html_tag && html_tag['lang']
+        '<html> must declare a non-blank lang attribute' if lang.nil? || lang.strip.empty?
+      end
+
+      sig { params(mail: T.untyped).returns(T.nilable(String)) }
+      def translation_missing_text_message(mail)
+        text = "#{mail.subject}\n#{PreviewRenderer.text_body(mail)}"
+        'subject or text part contains a missing i18n translation' if text.match?(MISSING_TRANSLATION)
+      end
+
+      sig { params(mail: T.untyped).returns(T.nilable(String)) }
+      def html_part_present_message(mail)
+        'message has no HTML part' if PreviewRenderer.html_body(mail).empty?
+      end
+
+      sig { params(mail: T.untyped).returns(T.nilable(String)) }
+      def text_part_present_message(mail)
+        return if mail.multipart? && !PreviewRenderer.text_body(mail).strip.empty?
+
+        'message must be multipart with a non-empty text/plain part'
+      end
+
+      sig { params(mail: T.untyped).returns(T.nilable(String)) }
+      def text_part_plain_message(mail)
+        'text/plain part contains HTML markup' if PreviewRenderer.text_body(mail).match?(MARKUP_IN_TEXT)
+      end
+    end
+  end
+end

data/lib/activemail/quality/configuration.rb

@@ -1,15 +1,20 @@
 # typed: strict
 # frozen_string_literal: true
 
+require 'i18n'
 require 'sorbet-runtime'
 
 require_relative 'guard'
+require_relative 'output_dir'
 
 module ActiveMail
   module Quality
     class Configuration
       extend T::Sig
 
+      FORMATS = T.let(%i[html text].freeze, T::Array[Symbol])
+      DEFAULT_LOCALES = T.let(->(_preview) { [I18n.default_locale] }, Proc)
+
       sig { returns(Guard) }
       attr_reader :guard
 
@@ -25,9 +30,7 @@ module ActiveMail
 
       sig { params(value: String).void }
       def output_dir=(value)
-        raise ArgumentError, 'output_dir must not be blank' if value.strip.empty?
-
-        @output_dir = value
+        @output_dir = OutputDir.validate!(value)
       end
 
       # Preview keys ("preview_name#email") that MUST render and pass the guard;
@@ -45,11 +48,88 @@ module ActiveMail
         @required_previews = value.to_a.map(&:to_s)
       end
 
+      sig { returns(T.any(T::Array[Symbol], Proc)) }
+      attr_reader :locales
+
+      sig { params(value: T.untyped).void }
+      def locales=(value)
+        @locales = value.is_a?(Proc) ? value : normalize_locales(value)
+      end
+
+      sig { params(preview: T.untyped).returns(T::Array[Symbol]) }
+      def locales_for(preview)
+        value = @locales
+        value.is_a?(Proc) ? normalize_locales(value.call(preview)) : value
+      end
+
+      sig { returns(T::Array[Symbol]) }
+      def formats
+        @formats.dup.freeze
+      end
+
+      sig { params(value: T.untyped).void }
+      def formats=(value)
+        raise TypeError, "formats must be an Array, got #{value.class}" unless value.is_a?(Array)
+
+        formats = value.map(&:to_sym)
+        unknown = formats - FORMATS
+        raise ArgumentError, "unknown format(s): #{unknown.inspect}, expected a subset of #{FORMATS.inspect}" unless unknown.empty?
+        raise ArgumentError, 'formats must not be empty' if formats.empty?
+
+        @formats = formats.uniq
+      end
+
+      # ->(preview, email, locale, &block) wrapping each rendering; it must call block.
+      sig { returns(T.nilable(Proc)) }
+      attr_reader :around_each
+
+      sig { params(value: T.untyped).void }
+      def around_each=(value)
+        raise TypeError, "around_each must be a Proc or nil, got #{value.class}" unless value.nil? || value.is_a?(Proc)
+
+        @around_each = value
+      end
+
+      # Applied to written files only: the Guard always sees the unfiltered content.
+      sig { returns(T::Array[Proc]) }
+      attr_reader :output_filters
+
+      sig { params(value: T.untyped).void }
+      def output_filters=(value)
+        raise TypeError, "output_filters must be an Array, got #{value.class}" unless value.is_a?(Array)
+
+        @output_filters = value.map { |filter| output_filter(filter) }
+      end
+
       sig { void }
       def initialize
         @guard = T.let(Guard.new, Guard)
         @output_dir = T.let('tmp/activemail_previews', String)
         @required_previews = T.let([], T::Array[String])
+        @locales = T.let(DEFAULT_LOCALES, T.any(T::Array[Symbol], Proc))
+        @formats = T.let(FORMATS, T::Array[Symbol])
+        @around_each = T.let(nil, T.nilable(Proc))
+        @output_filters = T.let([], T::Array[Proc])
+      end
+
+      private
+
+      sig { params(value: T.untyped).returns(T::Array[Symbol]) }
+      def normalize_locales(value)
+        raise TypeError, "locales must be an Array, got #{value.class}" unless value.is_a?(Array)
+        raise ArgumentError, 'locales must not be empty' if value.empty?
+
+        value.map(&:to_sym)
+      end
+
+      sig { params(filter: T.untyped).returns(Proc) }
+      def output_filter(filter)
+        return filter if filter.is_a?(Proc)
+
+        pattern, replacement = filter if filter.is_a?(Array) && filter.size == 2
+        raise TypeError, "output filter must be a Proc or [Regexp, String], got #{filter.inspect}" unless pattern.is_a?(Regexp) && replacement.is_a?(String)
+
+        ->(content) { content.gsub(pattern, replacement) }
       end
     end
   end