siftly-rails 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 5a64b92b6f28032c4a3284e1d718c1c432bc9d5537c35ec5b2762797658de24c
+  data.tar.gz: c86c1d29b33eac1d9c24a51a8b0ff29a7bf4bf2509cd9017248391f0321c80a2
+SHA512:
+  metadata.gz: 27192b24f4b2e69b02a1dc937bcac2cbaf4f0aee6508add3e7cd06643afb440b6c786b8d982fda8baffe5b80508caac587ed7b81f935e0cf28119315c12caa66
+  data.tar.gz: 03ea60160b8b602fd5d8038ec7a951e847c0abe5bdd9b6bc53a312ab5249ae92b2109c9a4490a89d9fdb2b2e0957af822125948e0fa64aa88d09f8f4208fed34

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+# Changelog
+
+## 0.1.0
+
+- Initial release.

data/Gemfile

@@ -0,0 +1,3 @@
+source "https://rubygems.org"
+
+gemspec

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Tomos Rees
+
+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,150 @@
+# Siftly::Rails
+
+`siftly-rails` wires `Siftly.check` into Active Model and Active Record validations. Use it when you want attributes checked automatically during validation and want the results attached to the model instance.
+
+## Installation
+
+```ruby
+gem "siftly-rails"
+```
+
+```ruby
+require "siftly/rails"
+```
+
+Requiring `siftly/rails` auto-includes `Siftly::Rails::Model` into all Active Record models via `ActiveSupport.on_load(:active_record)`. You still need to require whichever plugin gems provide the filters you want — `siftly-rails` only adds the model integration layer.
+
+For plain Active Model objects that don't inherit from `ActiveRecord::Base`, include the concern manually with `include Siftly::Rails::Model`.
+
+## Quick Start
+
+First configure the normal Siftly pipeline:
+
+```ruby
+Siftly.configure do |config|
+  config.aggregator = :score
+  config.threshold = 1.0
+  config.use :keyword_pack
+
+  config.filter :keyword_pack do |filter|
+    filter.keywords = ["spam", "buy now"]
+    filter.weight = 1.0
+  end
+end
+```
+
+Then declare the attributes to check:
+
+```ruby
+class ContactRequest < ApplicationRecord
+  siftly_check :email, :message, message: "contains spam"
+end
+```
+
+At validation time, each declared attribute is checked with:
+
+- `value:` the attribute value
+- `attribute:` the attribute name
+- `record:` the model instance
+- `context:` resolved from the check options
+- `filter_overrides:` resolved from the check options
+
+Example:
+
+```ruby
+request = ContactRequest.new(email: "spam@example.com", message: "buy now")
+
+request.valid?                           # => false
+request.siftly_spam?                     # => true
+request.siftly_spam_attributes           # => [:email, :message]
+request.siftly_results.keys              # => [:email, :message]
+request.siftly_spam_result_for(:message) # => #<Siftly::Result ...>
+```
+
+## What `siftly_check` Does
+
+Each `siftly_check` call:
+
+- registers one validation callback for the declared attributes
+- runs `Siftly.check` once per attribute
+- stores the latest result per attribute in `@siftly_results`
+- adds an Active Model error when a result is spam
+
+The spam-tracking state is reset in `before_validation`, so old results do not leak across revalidation.
+
+## Supported Options
+
+Siftly options passed through to `Siftly.check`:
+
+- `filters`
+- `filter_overrides`
+- `aggregator`
+- `threshold`
+- `failure_mode`
+- `instrumenter`
+- `context`
+
+Model-side validation behavior:
+
+- `allow_nil`
+- `allow_blank`
+- `message`
+- `strict`
+
+Active Model callback options:
+
+- `if`
+- `unless`
+- `on`
+
+## Option Resolution
+
+Every non-callback option can be a literal value or a callable. This is broader than just `context` and `filter_overrides`.
+
+Callables are executed via `instance_exec` on the model instance, so `self` inside the block is the record. Arity determines which explicit arguments are passed:
+
+- arity `0`: no arguments (access the record through `self`)
+- arity `1`: `attribute`
+- arity `2+`: `attribute` and `record`
+
+Example:
+
+```ruby
+class Lead < ApplicationRecord
+  siftly_check :message,
+    filters: -> { [:keyword_pack] },
+    filter_overrides: ->(attribute) { { keyword_pack: { keywords: [trigger_phrase], weight: 1.2 } } },
+    context: ->(attribute, record) { { source: "#{attribute}:#{record.source_name}" } },
+    allow_blank: true
+end
+```
+
+## Skip Behavior
+
+A check is skipped entirely when:
+
+- `allow_nil` is truthy and the value is `nil`
+- `allow_blank` is truthy and the value is blank
+
+Skipped checks:
+
+- do not call `Siftly.check`
+- do not store a result for that attribute
+- do not add errors
+
+## Exposed Instance Helpers
+
+Instances get:
+
+- `siftly_spam?`
+- `siftly_results`
+- `siftly_result_for(attribute)`
+- `siftly_spam_attributes`
+- `siftly_spam_results`
+- `siftly_spam_result_for(attribute)`
+
+## Practical Advice
+
+- Scope `filters:` per model when different models need different spam rules. Relying only on global configuration is how you end up checking everything with everything.
+- Remember that `siftly-rails` does not decide what counts as spam. It just runs the configured pipeline during validation.
+- If a filter is flaky or network-backed, set `failure_mode` deliberately. Pretending the default is fine without thinking about it is lazy.

data/Rakefile

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require "rake/testtask"
+
+Rake::TestTask.new do |test|
+  test.libs << "lib" << "test"
+  test.pattern = "test/**/*_test.rb"
+end
+
+task default: :test

data/lib/siftly/rails/attribute_check.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Siftly
+  module Rails
+    class AttributeCheck
+      CALLBACK_OPTIONS = %i[if unless on].freeze
+
+      attr_reader :attribute, :options
+
+      def initialize(attribute, options = {})
+        @attribute = attribute.to_sym
+        @options = options.transform_keys(&:to_sym).freeze
+      end
+
+      def callback_options
+        select_options(CALLBACK_OPTIONS)
+      end
+
+      def siftly_options
+        options.reject { |key, _value| CALLBACK_OPTIONS.include?(key) }
+      end
+
+      private
+
+      def select_options(keys)
+        options.each_with_object({}) do |(key, value), result|
+          result[key] = value if keys.include?(key)
+        end
+      end
+    end
+  end
+end

data/lib/siftly/rails/model.rb

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+require "active_support/concern"
+require "active_support/core_ext/class/attribute"
+
+module Siftly
+  module Rails
+    module Model
+      extend ActiveSupport::Concern
+
+      DEFAULT_ERROR_MESSAGE = "was flagged as spam"
+      CHECK_OPTION_KEYS = %i[
+        filters
+        filter_overrides
+        aggregator
+        threshold
+        failure_mode
+        instrumenter
+        context
+      ].freeze
+
+      included do
+        class_attribute :siftly_attribute_checks, instance_accessor: false, default: []
+        before_validation :reset_siftly_spam_tracking
+      end
+
+      class_methods do
+        def siftly_check(*attributes, **options)
+          raise ArgumentError, "siftly_check requires at least one attribute" if attributes.empty?
+
+          checks = attributes.map { |attribute| AttributeCheck.new(attribute, options) }
+          self.siftly_attribute_checks = siftly_attribute_checks + checks
+
+          validate(**checks.first.callback_options) do
+            checks.each { |check| run_siftly_check(check) }
+          end
+        end
+      end
+
+      def siftly_spam?
+        siftly_spam_attributes.any?
+      end
+
+      def siftly_results
+        current_siftly_results.dup
+      end
+
+      def siftly_result_for(attribute)
+        current_siftly_results[attribute.to_sym]
+      end
+
+      def siftly_spam_attributes
+        siftly_spam_results.keys
+      end
+
+      def siftly_spam_results
+        current_siftly_results.each_with_object({}) do |(attribute, result), spam_results|
+          spam_results[attribute] = result if result.spam?
+        end
+      end
+
+      def siftly_spam_result_for(attribute)
+        siftly_spam_results[attribute.to_sym]
+      end
+
+      private
+
+      def current_siftly_results
+        @siftly_results ||= {}
+      end
+
+      def reset_siftly_spam_tracking
+        @siftly_results = {}
+      end
+
+      def run_siftly_check(check)
+        return if skip_siftly_check?(check)
+
+        result = Siftly.check(**build_siftly_arguments(check))
+        current_siftly_results[check.attribute] = result
+
+        add_siftly_error(check) if result.spam?
+      end
+
+      def skip_siftly_check?(check)
+        value = public_send(check.attribute)
+
+        return true if truthy_option?(check, :allow_nil) && value.nil?
+        return true if truthy_option?(check, :allow_blank) && blank_value?(value)
+
+        false
+      end
+
+      def build_siftly_arguments(check)
+        arguments = {
+          value: public_send(check.attribute),
+          attribute: check.attribute,
+          record: self,
+          context: resolve_check_option(check, :context) || {},
+          filter_overrides: resolve_check_option(check, :filter_overrides) || {}
+        }
+
+        CHECK_OPTION_KEYS.each do |key|
+          next if %i[context filter_overrides].include?(key)
+
+          value = resolve_check_option(check, key)
+          arguments[key] = value unless value.nil?
+        end
+
+        arguments
+      end
+
+      def add_siftly_error(check)
+        options = {}
+        strict = resolve_check_option(check, :strict)
+        options[:strict] = strict unless strict.nil?
+
+        errors.add(check.attribute, resolve_check_option(check, :message) || DEFAULT_ERROR_MESSAGE, **options)
+      end
+
+      def truthy_option?(check, key)
+        !!resolve_check_option(check, key)
+      end
+
+      def resolve_check_option(check, key)
+        value = check.siftly_options[key]
+        return value unless value.respond_to?(:call)
+
+        case value.arity
+        when 0
+          instance_exec(&value)
+        when 1
+          instance_exec(check.attribute, &value)
+        else
+          instance_exec(check.attribute, self, &value)
+        end
+      end
+
+      def blank_value?(value)
+        return true if value.nil?
+        return value.blank? if value.respond_to?(:blank?)
+        return value.empty? if value.respond_to?(:empty?)
+
+        false
+      end
+    end
+  end
+end

data/lib/siftly/rails/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Siftly
+  module Rails
+    VERSION = "0.1.0"
+  end
+end

data/lib/siftly/rails.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require "siftly"
+require "active_support/lazy_load_hooks"
+require_relative "rails/version"
+require_relative "rails/attribute_check"
+require_relative "rails/model"
+
+ActiveSupport.on_load(:active_record) do
+  include Siftly::Rails::Model
+end

data/siftly-rails.gemspec

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require_relative "lib/siftly/rails/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "siftly-rails"
+  spec.version = Siftly::Rails::VERSION
+  spec.authors = ["Tomos Rees"]
+
+  spec.summary = "Active Record integration for the Siftly spam filtering core."
+  spec.description = "Siftly::Rails lets Rails applications validate model attributes with Siftly and inspect flagged attributes through the model instance."
+  spec.homepage = "https://github.com/tomosjohnrees/siftly-rails"
+  spec.license = "MIT"
+  spec.required_ruby_version = ">= 3.2"
+
+  spec.metadata["source_code_uri"] = spec.homepage
+  spec.metadata["changelog_uri"] = "#{spec.homepage}/blob/main/CHANGELOG.md"
+
+  spec.files = Dir.glob("{lib,test}/**/*") + %w[CHANGELOG.md Gemfile LICENSE README.md Rakefile siftly-rails.gemspec]
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "activerecord", ">= 7.1"
+  spec.add_dependency "activesupport", ">= 7.1"
+  spec.add_dependency "siftly", "~> 0.1.0"
+
+  spec.add_development_dependency "minitest", "= 6.0.2"
+  spec.add_development_dependency "rake", "~> 13.0"
+  spec.add_development_dependency "sqlite3", "~> 2.0"
+end

data/test/model_test.rb

@@ -0,0 +1,258 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class ModelTest < Minitest::Test
+  def test_flagged_attributes_are_exposed_on_the_model
+    Siftly.configure do |config|
+      config.use :test_keyword
+
+      config.filter :test_keyword do |filter|
+        filter.keywords = ["spam"]
+        filter.weight = 1.0
+      end
+    end
+
+    model_class = Class.new(SiftlyRailsRecord) do
+      siftly_check :email, :message, message: "contains spam"
+    end
+
+    record = model_class.new(email: "spam@example.com", message: "this message is spam", title: "hello")
+
+    refute record.valid?
+    assert_equal [:email, :message], record.siftly_spam_attributes.sort
+    assert record.siftly_spam?
+    assert_equal ["contains spam"], record.errors[:email]
+    assert_equal ["contains spam"], record.errors[:message]
+    assert_equal [:email, :message], record.siftly_results.keys.sort
+    assert_equal [:test_keyword], record.siftly_spam_result_for(:email).matches.map(&:filter)
+  end
+
+  def test_revalidation_clears_previous_spam_state
+    Siftly.configure do |config|
+      config.use :test_keyword
+
+      config.filter :test_keyword do |filter|
+        filter.keywords = ["spam"]
+      end
+    end
+
+    model_class = Class.new(SiftlyRailsRecord) do
+      siftly_check :message
+    end
+
+    record = model_class.new(message: "spam offer")
+
+    refute record.valid?
+    assert_equal [:message], record.siftly_spam_attributes
+
+    record.message = "ordinary text"
+
+    assert record.valid?
+    assert_empty record.siftly_spam_attributes
+    assert_nil record.siftly_spam_result_for(:message)
+    refute record.siftly_result_for(:message).spam?
+    assert_empty record.errors[:message]
+  end
+
+  def test_callable_options_can_build_context_and_filter_overrides
+    model_class = Class.new(SiftlyRailsRecord) do
+      siftly_check :message,
+        filters: [:test_keyword],
+        filter_overrides: ->(attribute) { { test_keyword: { keywords: [trigger_phrase], weight: 1.2 } } },
+        context: ->(attribute) { { source: "#{attribute}:#{source_name}" } }
+    end
+
+    record = model_class.new(message: "limited offer today", trigger_phrase: "offer", source_name: "landing-page")
+
+    refute record.valid?
+
+    result = record.siftly_spam_result_for(:message)
+
+    assert result.spam?
+    assert_equal "message matched offer", result.reasons.first
+    assert_equal "message:landing-page", result.matches.first.metadata[:source]
+  end
+
+  def test_allow_blank_skips_checking
+    model_class = Class.new(SiftlyRailsRecord) do
+      siftly_check :message, filters: [:test_keyword], allow_blank: true
+    end
+
+    record = model_class.new(message: "")
+
+    assert record.valid?
+    refute record.siftly_spam?
+    assert_nil record.siftly_spam_result_for(:message)
+  end
+
+  def test_allow_nil_skips_checking
+    model_class = Class.new(SiftlyRailsRecord) do
+      siftly_check :message, filters: [:test_keyword], allow_nil: true
+    end
+
+    record = model_class.new(message: nil)
+
+    assert record.valid?
+    refute record.siftly_spam?
+    assert_nil record.siftly_result_for(:message)
+  end
+
+  def test_allow_nil_does_not_skip_blank_strings
+    Siftly.configure do |config|
+      config.use :test_keyword
+      config.filter(:test_keyword) { |f| f.keywords = [""] }
+    end
+
+    model_class = Class.new(SiftlyRailsRecord) do
+      siftly_check :message, filters: [:test_keyword], allow_nil: true
+    end
+
+    record = model_class.new(message: "")
+
+    # allow_nil: true should NOT skip blank strings — only nil
+    assert_kind_of Siftly::Result, record.siftly_result_for(:message) unless record.valid?
+  end
+
+  def test_clean_submission_passes_validation
+    Siftly.configure do |config|
+      config.use :test_keyword
+      config.filter(:test_keyword) { |f| f.keywords = ["spam"] }
+    end
+
+    model_class = Class.new(SiftlyRailsRecord) do
+      siftly_check :message
+    end
+
+    record = model_class.new(message: "perfectly normal text")
+
+    assert record.valid?
+    refute record.siftly_spam?
+    assert_empty record.siftly_spam_attributes
+    refute record.siftly_result_for(:message).spam?
+  end
+
+  def test_strict_option_raises_on_spam
+    Siftly.configure do |config|
+      config.use :test_keyword
+      config.filter(:test_keyword) { |f| f.keywords = ["spam"]; f.weight = 1.0 }
+    end
+
+    model_class = Class.new(SiftlyRailsRecord) do
+      def self.name = "StrictSubmission"
+      siftly_check :message, strict: true
+    end
+
+    record = model_class.new(message: "this is spam")
+
+    assert_raises(ActiveModel::StrictValidationFailed) { record.valid? }
+  end
+
+  def test_if_condition_prevents_check_when_falsy
+    Siftly.configure do |config|
+      config.use :test_keyword
+      config.filter(:test_keyword) { |f| f.keywords = ["spam"]; f.weight = 1.0 }
+    end
+
+    model_class = Class.new(SiftlyRailsRecord) do
+      siftly_check :message, if: -> { source_name == "trusted" }
+    end
+
+    record = model_class.new(message: "spam offer", source_name: "untrusted")
+    assert record.valid?
+
+    record.source_name = "trusted"
+    refute record.valid?
+    assert record.siftly_spam?
+  end
+
+  def test_unless_condition_prevents_check_when_truthy
+    Siftly.configure do |config|
+      config.use :test_keyword
+      config.filter(:test_keyword) { |f| f.keywords = ["spam"]; f.weight = 1.0 }
+    end
+
+    model_class = Class.new(SiftlyRailsRecord) do
+      siftly_check :message, unless: -> { source_name == "trusted" }
+    end
+
+    record = model_class.new(message: "spam offer", source_name: "trusted")
+    assert record.valid?
+
+    record.source_name = "untrusted"
+    refute record.valid?
+  end
+
+  def test_siftly_check_requires_at_least_one_attribute
+    assert_raises(ArgumentError) do
+      Class.new(SiftlyRailsRecord) do
+        siftly_check
+      end
+    end
+  end
+
+  def test_multiple_siftly_check_declarations
+    Siftly.configure do |config|
+      config.use :test_keyword
+      config.filter(:test_keyword) { |f| f.keywords = ["spam"]; f.weight = 1.0 }
+    end
+
+    model_class = Class.new(SiftlyRailsRecord) do
+      siftly_check :email
+      siftly_check :message, message: "message spam"
+    end
+
+    record = model_class.new(email: "spam@example.com", message: "spam offer")
+
+    refute record.valid?
+    assert_equal [:email, :message], record.siftly_spam_attributes.sort
+    assert_equal ["was flagged as spam"], record.errors[:email]
+    assert_equal ["message spam"], record.errors[:message]
+  end
+
+  def test_callable_context_with_zero_arity
+    Siftly.configure do |config|
+      config.use :test_keyword
+      config.filter(:test_keyword) { |f| f.keywords = ["spam"]; f.weight = 1.0 }
+    end
+
+    model_class = Class.new(SiftlyRailsRecord) do
+      siftly_check :message,
+        context: -> { { source: "zero-arity" } }
+    end
+
+    record = model_class.new(message: "spam")
+
+    refute record.valid?
+    assert_equal "zero-arity", record.siftly_spam_result_for(:message).matches.first.metadata[:source]
+  end
+
+  def test_callable_filter_overrides_with_two_arity
+    model_class = Class.new(SiftlyRailsRecord) do
+      siftly_check :message,
+        filters: [:test_keyword],
+        filter_overrides: ->(attribute, record) { { test_keyword: { keywords: [record.trigger_phrase], weight: 1.0 } } }
+    end
+
+    record = model_class.new(message: "limited offer", trigger_phrase: "offer")
+
+    refute record.valid?
+    assert record.siftly_spam?
+  end
+
+  def test_default_error_message
+    Siftly.configure do |config|
+      config.use :test_keyword
+      config.filter(:test_keyword) { |f| f.keywords = ["spam"]; f.weight = 1.0 }
+    end
+
+    model_class = Class.new(SiftlyRailsRecord) do
+      siftly_check :message
+    end
+
+    record = model_class.new(message: "spam")
+
+    refute record.valid?
+    assert_equal ["was flagged as spam"], record.errors[:message]
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require "bundler/setup"
+
+$LOAD_PATH.unshift(File.expand_path("../lib", __dir__))
+
+require "minitest/autorun"
+require "active_record"
+require "sqlite3"
+require "siftly"
+require "siftly/rails"
+
+ActiveRecord::Base.establish_connection(adapter: "sqlite3", database: ":memory:")
+ActiveRecord::Schema.verbose = false
+
+ActiveRecord::Schema.define do
+  create_table :submissions, force: true do |table|
+    table.string :email
+    table.string :title
+    table.text :message
+    table.string :trigger_phrase
+    table.string :source_name
+  end
+end
+
+class SiftlyRailsTestFilter < Siftly::Filter
+  register_as :test_keyword
+
+  def call(value:, attribute: nil, record: nil, context: {})
+    keywords = Array(config.fetch(:keywords, []))
+    matched_keyword = keywords.find { |keyword| value.to_s.downcase.include?(keyword.downcase) }
+
+    result(
+      matched: !matched_keyword.nil?,
+      score: matched_keyword ? config.fetch(:weight, 1.0) : 0.0,
+      reason: matched_keyword ? "#{attribute} matched #{matched_keyword}" : nil,
+      metadata: {
+        matched_keyword: matched_keyword,
+        source: context[:source],
+        record_class: record.class.name
+      }
+    )
+  end
+end
+
+class SiftlyRailsRecord < ActiveRecord::Base
+  self.abstract_class = true
+  self.table_name = "submissions"
+end
+
+class Minitest::Test
+  def setup
+    super
+    Siftly.reset_configuration!
+    Siftly::Registry.clear
+    Siftly::Registry.register(SiftlyRailsTestFilter)
+  end
+end

metadata

@@ -0,0 +1,137 @@
+--- !ruby/object:Gem::Specification
+name: siftly-rails
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Tomos Rees
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.1'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.1'
+- !ruby/object:Gem::Dependency
+  name: siftly
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 6.0.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 6.0.2
+- !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: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+description: Siftly::Rails lets Rails applications validate model attributes with
+  Siftly and inspect flagged attributes through the model instance.
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- lib/siftly/rails.rb
+- lib/siftly/rails/attribute_check.rb
+- lib/siftly/rails/model.rb
+- lib/siftly/rails/version.rb
+- siftly-rails.gemspec
+- test/model_test.rb
+- test/test_helper.rb
+homepage: https://github.com/tomosjohnrees/siftly-rails
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/tomosjohnrees/siftly-rails
+  changelog_uri: https://github.com/tomosjohnrees/siftly-rails/blob/main/CHANGELOG.md
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.2'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: Active Record integration for the Siftly spam filtering core.
+test_files: []