strict_pagination 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 7234dbd288be581e5a708b4c854d4918e7ddb7f79c80c13d4be3f3cfd681bf23
+  data.tar.gz: 9edfc21298022007fa6727da2d93b92ee5ff160ab9bb094de7a43f24749c14f6
+SHA512:
+  metadata.gz: c4fea6505c3b97324c0520271ddfbd722aacec173ab014fd969f459de5d6fca545b7eb5fb5cf59a41e17344a7948ebaf582c17925f4c52f8b61d1b027f7a8126
+  data.tar.gz: e074c0ebcbf7cc4664ecfad44552b1ba67f58478b6602b2af14a82d67af45d2f3d4781cdbf09a5cd200d66946fe368c66d3ba0ba93908d298f1a6124a3d5b20b

data/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 [Your Name]
+
+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,322 @@
+# StrictPagination
+
+A Ruby gem that adds strict pagination validation to ActiveRecord, preventing unsafe JOINs that can cause inconsistent pagination results.
+
+## Problem
+
+When using LIMIT/OFFSET with DISTINCT and JOINs to associations that multiply rows (like `has_many` or unsafe `has_one`), pagination can become inconsistent. This happens because:
+
+1. JOINs multiply rows (e.g., a User with 3 posts becomes 3 rows)
+2. DISTINCT collapses them back to 1 row
+3. But LIMIT is applied BEFORE DISTINCT, not after
+4. Result: inconsistent page sizes and missing records
+
+## Solution
+
+This gem provides `strict_pagination` mode that validates queries before execution, ensuring they don't use JOINs that multiply rows when using pagination.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'strict_pagination'
+```
+
+And then execute:
+
+```bash
+bundle install
+```
+
+Or install it yourself as:
+
+```bash
+gem install strict_pagination
+```
+
+## Usage
+
+### Basic Usage
+
+Simply add `.strict_pagination` to your ActiveRecord queries with DISTINCT:
+
+```ruby
+# Safe: no associations
+User.strict_pagination.distinct.page(1).per(10)
+
+# Safe: belongs_to associations don't multiply rows
+Article.strict_pagination
+       .includes(:author)
+       .distinct
+       .page(1).per(10)
+
+# Safe: view-backed has_one associations
+Order.strict_pagination
+     .includes(:latest_payment)  # backed by a database view
+     .distinct
+     .page(1).per(10)
+
+# ERROR: has_many multiplies rows
+User.strict_pagination
+    .includes(:posts)
+    .distinct
+    .page(1).per(10)
+# => StrictPagination::ViolationError
+```
+
+**Note:** Validation only runs when **both** `LIMIT` (from `.page()`) and `DISTINCT` are present. This is because the pagination issue only occurs with DISTINCT queries.
+
+### When is Validation Triggered?
+
+The validation only runs when BOTH conditions are met:
+- Query has `LIMIT` (pagination)
+- Query has `DISTINCT`
+
+This means you can use `strict_pagination` safely on all queries, and it will only validate when necessary.
+
+### Safe Associations
+
+The following associations are considered safe:
+
+1. **belongs_to** - Never multiplies rows
+2. **has_one backed by database views** - Views starting with `Views::` or table names starting with `views_`
+3. **has_one with unique constraint** - When the foreign key has a unique index
+
+### Unsafe Associations
+
+The following associations will trigger an error:
+
+1. **has_many** - Always multiplies rows
+2. **has_and_belongs_to_many** - Always multiplies rows
+3. **has_one without unique constraint** - Can multiply rows
+
+### Error Messages
+
+When a violation is detected, you'll get a detailed error message:
+
+```
+StrictPagination::ViolationError: Strict pagination violation: The query includes unsafe
+associations `posts` that can multiply rows, causing inconsistent pagination with
+LIMIT/OFFSET + DISTINCT.
+
+Unsafe associations detected:
+  - posts: has_many (always multiplies rows)
+
+Solutions:
+1. Remove `posts` from the query's includes/preload/eager_load/joins
+2. Replace has_many with has_one backed by a database view (automatically safe)
+3. Add a unique constraint to the foreign key (for has_one associations)
+4. Remove .strict_pagination if you understand the pagination risks
+```
+
+## Configuration
+
+You can configure the gem's behavior using an initializer:
+
+```ruby
+# config/initializers/strict_pagination.rb
+
+StrictPagination.configure do |config|
+  # Validate all paginated queries, even without DISTINCT
+  # Default: false (only validates with DISTINCT)
+  config.validate_on_all_queries = false
+
+  # Add custom view prefixes to consider as safe
+  # Default: [] (uses "Views::" and "views_" by default)
+  config.safe_view_prefixes = ['Reports::', 'Analytics::']
+end
+```
+
+### Configuration Options
+
+#### `validate_on_all_queries`
+
+By default, validation only runs when a query has both `LIMIT` and `DISTINCT`. Set this to `true` to validate all paginated queries regardless of DISTINCT:
+
+```ruby
+StrictPagination.configure do |config|
+  config.validate_on_all_queries = true
+end
+
+# Now this will be validated even without DISTINCT
+User.strict_pagination.includes(:posts).limit(10)
+# => StrictPagination::ViolationError
+```
+
+#### `safe_view_prefixes`
+
+Add custom prefixes for view classes or table names that should be considered safe:
+
+```ruby
+StrictPagination.configure do |config|
+  config.safe_view_prefixes = ['Reports::', 'Analytics::']
+end
+
+# Now these are considered safe
+class Reports::UserSummary < ApplicationRecord; end
+Order.strict_pagination.includes(:user_summary).page(1)  # Safe
+```
+
+## Best Practices
+
+### For API Endpoints
+
+Use `strict_pagination` on all paginated API endpoints with DISTINCT:
+
+```ruby
+# app/controllers/api/v1/users_controller.rb
+def index
+  @users = User.strict_pagination
+               .includes(:profile)  # Safe: belongs_to
+               .distinct
+               .page(params[:page])
+               .per(params[:per_page])
+
+  render json: @users
+end
+```
+
+### Using Database Views for Safe has_one
+
+Replace `has_many` with `has_one` backed by a database view:
+
+```ruby
+# Instead of:
+class Author < ApplicationRecord
+  has_many :books
+end
+
+# Create a view for the latest book:
+# CREATE VIEW views_latest_books AS
+#   SELECT DISTINCT ON (author_id) *
+#   FROM books
+#   ORDER BY author_id, published_at DESC
+
+class Author < ApplicationRecord
+  has_one :latest_book, class_name: 'Views::LatestBook'
+end
+
+# Now safe to use with strict_pagination:
+Author.strict_pagination
+      .includes(:latest_book)
+      .distinct
+      .page(1).per(10)
+```
+
+### Gradual Adoption
+
+You can gradually adopt strict pagination in your codebase:
+
+```ruby
+# Start with critical endpoints
+class Api::V1::OrdersController < ApplicationController
+  def index
+    @orders = Order.strict_pagination.distinct.page(params[:page])
+  end
+end
+
+# Once confident, use it everywhere
+class ApplicationRecord < ActiveRecord::Base
+  # Override default scope to use strict_pagination
+  def self.paginated(**options)
+    strict_pagination.distinct.page(options[:page]).per(options[:per_page])
+  end
+end
+```
+
+## How It Works
+
+The gem:
+
+1. Adds a `strict_pagination` method to `ActiveRecord::Relation`
+2. Uses `prepend` to hook into query execution (`exec_queries`)
+3. Before executing, validates that no unsafe associations are included/joined
+4. Only validates when the query has LIMIT (and optionally DISTINCT)
+5. Raises `StrictPagination::ViolationError` if unsafe associations are detected
+
+### Architecture
+
+The gem follows Rails best practices:
+
+- **ActiveSupport::Concern** - For clean module inclusion
+- **ActiveSupport.on_load** - For proper Rails initialization
+- **Railtie** - For Rails lifecycle integration
+- **Prepend pattern** - For clean method overriding
+
+## Examples
+
+### Safe Queries
+
+```ruby
+# No associations
+User.strict_pagination.distinct.page(1).per(20)
+
+# belongs_to only
+Comment.strict_pagination
+       .includes(:author, :post)
+       .distinct
+       .page(1).per(20)
+
+# View-backed has_one
+Invoice.strict_pagination
+       .includes(:latest_payment)
+       .distinct
+       .page(1).per(20)
+
+# has_one with unique constraint
+User.strict_pagination
+    .includes(:profile)  # profiles.user_id has unique index
+    .distinct
+    .page(1).per(20)
+```
+
+### Unsafe Queries
+
+```ruby
+# has_many association
+User.strict_pagination
+    .includes(:posts)  # Error: posts multiplies rows
+    .distinct
+    .page(1).per(20)
+
+# has_and_belongs_to_many
+Article.strict_pagination
+       .includes(:tags)  # Error: tags multiplies rows
+       .distinct
+       .page(1).per(20)
+
+# has_one without unique constraint
+Account.strict_pagination
+       .includes(:primary_contact)  # Error: no unique constraint
+       .distinct
+       .page(1).per(20)
+```
+
+## Development
+
+After checking out the repo, run:
+
+```bash
+bundle install
+```
+
+To run tests:
+
+```bash
+bundle exec rspec
+```
+
+To build the gem:
+
+```bash
+gem build strict_pagination.gemspec
+```
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/hdamico/strict_pagination.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](LICENSE.txt).

data/lib/strict_pagination/active_record.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require "strict_pagination/version"
+require "strict_pagination/validator"
+require "strict_pagination/relation_methods"
+require "strict_pagination/relation_extension"
+require "active_support/lazy_load_hooks"
+
+ActiveSupport.on_load :active_record do
+  require "active_record"
+
+  ::ActiveRecord::Relation.include StrictPagination::RelationMethods
+  ::ActiveRecord::Relation.include StrictPagination::Validator
+  ::ActiveRecord::Relation.prepend StrictPagination::RelationExtension
+end

data/lib/strict_pagination/config.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module StrictPagination
+  # Configures global settings for StrictPagination
+  #   StrictPagination.configure do |config|
+  #     config.enabled_by_default = false
+  #     config.validate_on_all_queries = false
+  #   end
+  class << self
+    def configure
+      yield config
+    end
+
+    def config
+      @_config ||= Config.new
+    end
+  end
+
+  class Config
+    # Whether to enable strict_pagination by default on all queries
+    attr_accessor :enabled_by_default
+
+    # Whether to validate even without DISTINCT
+    # (useful if you want to enforce no JOINs on paginated queries regardless)
+    attr_accessor :validate_on_all_queries
+
+    # Custom view prefixes to consider as safe (in addition to "Views::" and "views_")
+    attr_accessor :safe_view_prefixes
+
+    def initialize
+      @enabled_by_default = false
+      @validate_on_all_queries = false
+      @safe_view_prefixes = []
+    end
+  end
+end

data/lib/strict_pagination/railtie.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module StrictPagination
+  class Railtie < ::Rails::Railtie
+    initializer "strict_pagination.configure_rails_initialization" do
+      ActiveSupport.on_load(:active_record) do
+        require "strict_pagination/active_record"
+      end
+    end
+  end
+end

data/lib/strict_pagination/relation_extension.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module StrictPagination
+  # Prepended module to hook into exec_queries
+  # Using prepend instead of alias_method is cleaner and more maintainable
+  module RelationExtension
+    def exec_queries
+      validate_strict_pagination! if strict_pagination_value
+      super
+    end
+  end
+end

data/lib/strict_pagination/relation_methods.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module StrictPagination
+  # Methods added to ActiveRecord::Relation for strict pagination validation
+  module RelationMethods
+    extend ActiveSupport::Concern
+
+    included do
+      # Add strict_pagination to SINGLE_VALUE_METHODS if not already present
+      self::SINGLE_VALUE_METHODS.push(:strict_pagination) unless self::SINGLE_VALUE_METHODS.include?(:strict_pagination)
+    end
+
+    ##
+    # Sets the strict_pagination mode for this relation.
+    #
+    # When strict_pagination is enabled, the query will be validated before execution
+    # to ensure it doesn't use JOINs that multiply rows (has_many, unsafe has_one).
+    # The validation only runs when the query has LIMIT (pagination).
+    #
+    # @param value [Boolean] whether to enable strict pagination
+    # @return [ActiveRecord::Relation] a new relation with strict_pagination enabled
+    #
+    # @example Enable strict pagination for a paginated API endpoint
+    #   products = Product.strict_pagination.page(1).per(10)
+    #   # Automatically validates on load
+    #
+    # @example Use with includes (will validate safety)
+    #   products = Product.strict_pagination
+    #                     .includes(:latest_active_deal)  # Safe has_one
+    #                     .page(1).per(10)
+    #   # No error - view-backed has_one is safe
+    #
+    # @example This will raise an error if a collection association is included
+    #   products = Product.strict_pagination
+    #                     .includes(:deals)  # Unsafe has_many
+    #                     .page(1).per(10)
+    #   # => StrictPagination::ViolationError
+    def strict_pagination(value: true)
+      spawn.strict_pagination!(value:)
+    end
+
+    ##
+    # Like #strict_pagination, but modifies relation in place.
+    # @private
+    def strict_pagination!(value: true)
+      self.strict_pagination_value = value
+      self
+    end
+
+    def strict_pagination_value
+      @values.fetch(:strict_pagination, false)
+    end
+
+    def strict_pagination_value=(value)
+      assert_modifiable!
+      @values[:strict_pagination] = value
+    end
+
+    private
+
+    ##
+    # Validates that the query is safe for pagination.
+    # Only validates if the query has LIMIT + DISTINCT (classic pagination scenario).
+    def validate_strict_pagination!
+      return unless limit_value
+
+      # Check if we should validate without DISTINCT requirement
+      unless StrictPagination.config.validate_on_all_queries
+        return unless distinct_value
+      end
+
+      # Get all unsafe associations that are actually included/joined
+      unsafe_associations = detect_unsafe_included_associations
+
+      return if unsafe_associations.empty?
+
+      raise_strict_pagination_violation!(unsafe_associations)
+    end
+  end
+end

data/lib/strict_pagination/validator.rb

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+module StrictPagination
+  module Validator
+    private
+
+    ##
+    # Detects all unsafe associations that are currently included/preloaded/joined.
+    def detect_unsafe_included_associations
+      unsafe       = Set.new
+      all_included = preloaded_association_names
+
+      check_collection_associations(unsafe, all_included, :has_many)
+      check_collection_associations(unsafe, all_included, :has_and_belongs_to_many)
+      check_has_one_associations(unsafe, all_included)
+      detect_unsafe_joins(unsafe)
+
+      unsafe.to_a
+    end
+
+    def preloaded_association_names
+      (includes_values + preload_values + eager_load_values).map do |value|
+        next value.keys.first if value.is_a?(Hash)
+
+        value
+      end
+    end
+
+    def check_collection_associations(unsafe, all_included, macro)
+      klass.reflect_on_all_associations(macro).each do |reflection|
+        unsafe << reflection.name.to_s if all_included.include?(reflection.name)
+      end
+    end
+
+    def check_has_one_associations(unsafe, all_included)
+      klass.reflect_on_all_associations(:has_one).each do |reflection|
+        next unless all_included.include?(reflection.name)
+        next if safe_has_one_association?(reflection)
+
+        unsafe << reflection.name.to_s
+      end
+    end
+
+    ##
+    # Checks if a has_one association is safe for pagination.
+    def safe_has_one_association?(reflection)
+      klass_obj = reflection.klass
+
+      # Check if it's a database view (default prefixes)
+      return true if klass_obj.name.start_with?("Views::")
+      return true if klass_obj.table_name.start_with?("views_")
+
+      # Check custom view prefixes from config
+      StrictPagination.config.safe_view_prefixes.each do |prefix|
+        return true if klass_obj.name.start_with?(prefix)
+        return true if klass_obj.table_name.start_with?(prefix.underscore)
+      end
+
+      # Check for unique constraint on the foreign key
+      unique_constraint_on_foreign_key?(klass_obj, reflection.foreign_key)
+    rescue StandardError
+      false
+    end
+
+    ##
+    # Checks if a table has a unique constraint on a specific column.
+    def unique_constraint_on_foreign_key?(klass_obj, foreign_key)
+      return false unless klass_obj.respond_to?(:connection)
+
+      klass_obj.connection.indexes(klass_obj.table_name).any? do |index|
+        index.unique && index.columns.include?(foreign_key.to_s)
+      end
+    rescue ActiveRecord::StatementInvalid
+      false
+    end
+
+    ##
+    # Detects unsafe associations in explicit joins_values.
+    def detect_unsafe_joins(unsafe)
+      joins_values.each do |join|
+        process_join(unsafe, join)
+      end
+    end
+
+    def process_join(unsafe, join)
+      case join
+      when Symbol, String
+        add_unsafe_join(unsafe, join.to_sym, join.to_s)
+      when Hash
+        join.each_key { |key| add_unsafe_join(unsafe, key.to_sym, key.to_s) }
+      end
+    end
+
+    def add_unsafe_join(unsafe, association_name, association_string)
+      reflection = klass.reflect_on_association(association_name)
+      return unless reflection
+      return if reflection.macro == :belongs_to
+
+      unsafe << association_string if unsafe_association?(reflection)
+    end
+
+    def unsafe_association?(reflection)
+      collection_macro?(reflection.macro) || unsafe_has_one?(reflection)
+    end
+
+    def collection_macro?(macro)
+      %i[has_many has_and_belongs_to_many].include?(macro)
+    end
+
+    def unsafe_has_one?(reflection)
+      reflection.macro == :has_one && !safe_has_one_association?(reflection)
+    end
+
+    ##
+    # Raises a detailed error message about the strict pagination violation.
+    def raise_strict_pagination_violation!(unsafe_associations)
+      message = build_error_message(unsafe_associations)
+      raise StrictPagination::ViolationError, message
+    end
+
+    def build_error_message(unsafe_associations)
+      associations_list    = unsafe_associations.map { |name| "`#{name}`" }.join(", ")
+      associations_details = unsafe_associations.map { |a| "  - #{a}: #{describe_association_type(a)}" }.join("\n")
+
+      <<~MSG.squish
+        Strict pagination violation: The query includes unsafe associations #{associations_list}
+        that can multiply rows, causing inconsistent pagination with LIMIT/OFFSET + DISTINCT.
+
+        Unsafe associations detected:
+        #{associations_details}
+
+        Solutions:
+        1. Remove #{associations_list} from the query's includes/preload/eager_load/joins
+        2. Replace has_many with has_one backed by a database view (automatically safe)
+        3. Add a unique constraint to the foreign key (for has_one associations)
+        4. Remove .strict_pagination if you understand the pagination risks
+      MSG
+    end
+
+    ##
+    # Describes the association type for error messages.
+    def describe_association_type(association_name)
+      reflection = klass.reflect_on_association(association_name.to_sym)
+      return "unknown" unless reflection
+
+      association_type_description(reflection.macro)
+    end
+
+    def association_type_description(macro)
+      case macro
+      when :has_many then "has_many (always multiplies rows)"
+      when :has_and_belongs_to_many then "has_and_belongs_to_many (always multiplies rows)"
+      when :has_one then "has_one without unique constraint (can multiply rows)"
+      else macro.to_s
+      end
+    end
+  end
+end

data/lib/strict_pagination/version.rb

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

data/lib/strict_pagination.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require "active_support/lazy_load_hooks"
+require "strict_pagination/version"
+require "strict_pagination/config"
+
+module StrictPagination
+  # Custom error raised when attempting pagination with unsafe JOINs
+  class ViolationError < ActiveRecord::ActiveRecordError
+  end
+end
+
+# Load Rails integration if Rails is available
+if defined?(Rails::Railtie)
+  require "strict_pagination/railtie"
+else
+  # For non-Rails environments, load ActiveRecord integration directly
+  require "strict_pagination/active_record"
+end

metadata

@@ -0,0 +1,102 @@
+--- !ruby/object:Gem::Specification
+name: strict_pagination
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- Hernán d'Amico
+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: '6.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '8.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '8.0'
+- !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: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: Adds strict_pagination mode to ActiveRecord::Relation to validate queries
+  before execution, ensuring they don't use JOINs that multiply rows (has_many, unsafe
+  has_one). Helps prevent inconsistent pagination with LIMIT/OFFSET + DISTINCT.
+email:
+- hernan.damico67@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- lib/strict_pagination.rb
+- lib/strict_pagination/active_record.rb
+- lib/strict_pagination/config.rb
+- lib/strict_pagination/railtie.rb
+- lib/strict_pagination/relation_extension.rb
+- lib/strict_pagination/relation_methods.rb
+- lib/strict_pagination/validator.rb
+- lib/strict_pagination/version.rb
+homepage: https://github.com/hdamico/strict_pagination
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/hdamico/strict_pagination
+  changelog_uri: https://github.com/hdamico/strict_pagination/blob/main/CHANGELOG.md
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.7.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.7.1
+specification_version: 4
+summary: Strict pagination validation for ActiveRecord to prevent unsafe JOINs
+test_files: []